home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Emulators / v2600 / Source.lha / Source / amiga_cpu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-25  |  78.1 KB  |  4,868 lines
  1. /*****************************************************************************
  2.  
  3.    This file is part of x2600, the Atari 2600 Emulator
  4.    ===================================================
  5.    
  6.    Copyright 1996 Alex Hornby. For contributions see the file CREDITS.
  7.  
  8.    This software is distributed under the terms of the GNU General Public
  9.    License. This is free software with ABSOLUTELY NO WARRANTY.
  10.    
  11.    See the file COPYING for details.
  12.    
  13.    Tweaked by Matthew Stroup for Amiga v2600, April 10, 1997.
  14.  
  15. ******************************************************************************/
  16. /* 
  17.  * 6507 CPU emulation
  18.  *
  19.  * Originally from X64
  20.  * Modified by Alex Hornby for use in x2600
  21.  * See COPYING for license terms
  22.  */
  23.  
  24. #include <stdio.h>
  25. #include "types.h"
  26. #include "cpu.h"
  27. #include "macro.h"
  28. #include "vmachine.h"
  29. #include "display.h"
  30. #include "misc.h"
  31. #include "config.h"
  32. #include "memory.h"
  33.  
  34. /* CPU internals */
  35. ADDRESS program_counter;
  36. UBYTE x_register, y_register, stack_pointer;
  37. UBYTE accumulator, status_register;
  38. int zero_flag;
  39. int sign_flag;
  40. int overflow_flag;
  41. int break_flag;
  42. int decimal_flag;
  43. int interrupt_flag;
  44. int carry_flag;
  45.  
  46. /* CPU Clock counts */
  47. /* Aggregate */
  48. CLOCK clk;
  49. /* Current instruction */
  50. CLOCK clkcount = 0;
  51.  
  52. /* Electron beam adjuctment values for nine and twelve colour clock ins. */
  53. #define BEAMNINE 5
  54. #define BEAMTWELVE 9
  55. int beamadj;
  56.  
  57. /* Used in undocumented 6507 instructions */
  58. /* These are unusual and have no discernable use, but here it is. */
  59. /* val: register to be acted upon */
  60. /* address: address to take high byte from */
  61. /* index: index to add to calculated address */
  62. #ifndef NO_UNDOC_CMDS
  63. void
  64. u_stoshr (unsigned int val, ADDRESS address, UBYTE index)
  65. {
  66.   val &= (((address >> 8) + 1) & 0xff);
  67.   if (((address & 0xff) + index) > 0xff)
  68.     address = val;
  69.   STORE ((address + index), val);
  70. }
  71. #endif /* UNDOC */
  72.  
  73. /* Initialise the CPU */
  74. /* addr: reset vector address */
  75. /* Called from init_hardware() */
  76. void
  77. init_cpu (ADDRESS addr)
  78. {
  79.   SET_SR (0x20);
  80.   SP = 0xff;
  81.   PC = LOAD_ADDR (addr);
  82.   clk = 0;
  83.   clkcount = 0;
  84. }
  85.  
  86. /* The main emulation loop, performs the CPU emulation */
  87. void
  88. mainloop (void)
  89. {
  90.   register UBYTE b;
  91.   init_hardware ();
  92.   while (1)
  93.     {
  94.       if (reset_flag)
  95.     {
  96.       reset_flag = 0;
  97.       if (fselLoad () != 0)
  98.         {
  99.           init_hardware ();
  100.         }
  101.     }
  102.       while (!reset_flag)
  103.     {
  104.       do_screen (clkcount);
  105.  
  106.       b = LOADEXEC (PC);
  107.       beamadj = 0;
  108.  
  109.       switch (b)
  110.         {
  111.         case 0:
  112.           {
  113.         PC++;
  114.         /* Force break. */
  115.  
  116.         SET_BREAK (1);    /* Set break status. */
  117.         PUSH (UPPER (PC));
  118.         PUSH (LOWER (PC));    /* Push return address into the stack. */
  119.         PUSH (GET_SR ());    /* Push status register into the stack. */
  120.         SET_INTERRUPT (1);    /* Disable interrupts. */
  121.         PC = LOAD_ADDR ((ADDRESS) 65534);    /* Jump using BRK vector (0xfffe). */
  122.         clkcount = 7;
  123.           }
  124.           break;
  125.  
  126.         case 1:
  127.           {
  128.         register p1 = LOAD (PC + 1);
  129.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  130.         PC += 2;
  131.  
  132.         src |= AC;
  133.         SET_SIGN (src);
  134.         SET_ZERO (src);
  135.  
  136.         AC = (src);;
  137.         clkcount = 6;
  138.           }
  139.  
  140.           break;
  141.  
  142.         case 3:
  143.           {
  144.         register p1 = LOAD (PC + 1);
  145.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  146.         PC += 2;
  147.  
  148.         /* src = asl(src); AC = ora(src); */
  149.  
  150.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  151.         src <<= 1;
  152.         src |= AC;
  153.         src &= 0xff;
  154.         SET_SIGN (src);
  155.         SET_ZERO (src);
  156.  
  157.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  158.         clkcount = 8;
  159.           }
  160.  
  161.           break;
  162.  
  163.         case 4:
  164.           {
  165.         PC += 2;
  166.  
  167.         clkcount = 3;
  168.           }
  169.  
  170.           break;
  171.  
  172.         case 5:
  173.           {
  174.         register p1 = LOAD (PC + 1);
  175.         register unsigned src = LOAD_ZERO (p1);
  176.         PC += 2;
  177.  
  178.         src |= AC;
  179.         SET_SIGN (src);
  180.         SET_ZERO (src);
  181.  
  182.         AC = (src);;
  183.         clkcount = 3;
  184.           }
  185.  
  186.           break;
  187.  
  188.         case 6:
  189.           {
  190.         register p1 = LOAD (PC + 1);
  191.         register unsigned src = LOAD_ZERO (p1);
  192.         PC += 2;
  193.  
  194.         SET_CARRY (src & 0x80);
  195.         src <<= 1;
  196.         src &= 0xff;
  197.         SET_SIGN (src);
  198.         SET_ZERO (src);
  199.  
  200.         STORE_ZERO (p1, (src));;
  201.         clkcount = 5;
  202.           }
  203.  
  204.           break;
  205.  
  206.         case 7:
  207.           {
  208.         register p1 = LOAD (PC + 1);
  209.         register unsigned src = LOAD_ZERO (p1);
  210.         PC += 2;
  211.  
  212.         /* src = asl(src); AC = ora(src); */
  213.  
  214.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  215.         src <<= 1;
  216.         src |= AC;
  217.         src &= 0xff;
  218.         SET_SIGN (src);
  219.         SET_ZERO (src);
  220.  
  221.         STORE_ZERO (p1, (src));;
  222.         clkcount = 5;
  223.           }
  224.  
  225.           break;
  226.  
  227.         case 8:
  228.           {
  229.         register unsigned src = GET_SR ();
  230.         PC++;
  231.  
  232.         PUSH (src);
  233.         /* First push item onto stack and then decrement SP. */
  234.         clkcount = 3;
  235.           }
  236.  
  237.           break;
  238.  
  239.         case 9:
  240.           {
  241.         register p1 = LOAD (PC + 1);
  242.         register unsigned src = p1;
  243.         PC += 2;
  244.  
  245.         src |= AC;
  246.         SET_SIGN (src);
  247.         SET_ZERO (src);
  248.  
  249.         AC = (src);;
  250.         clkcount = 2;
  251.           }
  252.  
  253.           break;
  254.  
  255.         case 10:
  256.           {
  257.         register unsigned src = AC;
  258.         PC++;
  259.  
  260.         SET_CARRY (src & 0x80);
  261.         src <<= 1;
  262.         src &= 0xff;
  263.         SET_SIGN (src);
  264.         SET_ZERO (src);
  265.  
  266.         AC = (src);;
  267.         clkcount = 2;
  268.           }
  269.  
  270.           break;
  271.  
  272.         case 11:
  273.           {
  274.         register p1 = LOAD (PC + 1);
  275.         register unsigned src = (AC & p1);
  276.         PC += 2;
  277.  
  278.         src &= AC;
  279.         SET_SIGN (src);
  280.         SET_ZERO (src);
  281.  
  282.         AC = (src);;
  283.         clkcount = 2;
  284.           }
  285.  
  286.           break;
  287.  
  288.         case 12:
  289.           {
  290.         PC += 3;
  291.  
  292.         clkcount = 4;
  293.           }
  294.  
  295.           break;
  296.  
  297.         case 13:
  298.           {
  299.         register p2 = load_abs_addr ();
  300.         register unsigned src = LOAD (p2);
  301.         PC += 3;
  302.  
  303.         src |= AC;
  304.         SET_SIGN (src);
  305.         SET_ZERO (src);
  306.  
  307.         AC = (src);;
  308.         clkcount = 4;
  309.           }
  310.  
  311.           break;
  312.  
  313.         case 14:
  314.           {
  315.         register p2 = load_abs_addr ();
  316.         register unsigned src = LOAD (p2);
  317.         PC += 3;
  318.  
  319.         SET_CARRY (src & 0x80);
  320.         src <<= 1;
  321.         src &= 0xff;
  322.         SET_SIGN (src);
  323.         SET_ZERO (src);
  324.  
  325.         STORE (p2, (src));;
  326.         clkcount = 6;
  327.           }
  328.  
  329.           break;
  330.  
  331.         case 15:
  332.           {
  333.         register p2 = load_abs_addr ();
  334.         register unsigned src = LOAD (p2);
  335.         PC += 3;
  336.  
  337.         /* src = asl(src); AC = ora(src); */
  338.  
  339.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  340.         src <<= 1;
  341.         src |= AC;
  342.         src &= 0xff;
  343.         SET_SIGN (src);
  344.         SET_ZERO (src);
  345.  
  346.         STORE (p2, (src));;
  347.         clkcount = 6;
  348.           }
  349.  
  350.           break;
  351.  
  352.         case 16:
  353. /*  BPL,    RELATIVE */
  354.           {
  355.         register p1 = LOAD (PC + 1);
  356.         register unsigned src = p1;
  357.         register UBYTE hb;
  358.         PC += 2;
  359.         /* Branch if sign flag is clear. */
  360.         if (!IF_SIGN ())
  361.           {
  362.             hb = UPPER (PC);
  363.             PC = REL_ADDR (PC, src);
  364.             if (brtest (hb))
  365.               /* Same page */
  366.               clkcount = 3;
  367.             else
  368.               /* Different page */
  369.               clkcount = 4;
  370.           }
  371.         else
  372.           clkcount = 2;
  373.           }
  374.  
  375.           break;
  376.  
  377.         case 17:
  378. /* ORA,    INDIRECT_Y */
  379.           {
  380.         register p1 = LOAD (PC + 1);
  381.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  382.         register unsigned src = LOAD (p2 + YR);
  383.         PC += 2;
  384.  
  385.         /* If low byte of address  + index reg is > 0xff then extra cycle */
  386.         if (pagetest (p2, YR))
  387.           /* Over page */
  388.           clkcount = 6;
  389.         else
  390.           /* Same page */
  391.           clkcount = 5;
  392.         src |= AC;
  393.         SET_SIGN (src);
  394.         SET_ZERO (src);
  395.  
  396.         AC = (src);;
  397.           }
  398.  
  399.           break;
  400.  
  401.         case 19:
  402.           {
  403.         register p1 = LOAD (PC + 1);
  404.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  405.         PC += 2;
  406.  
  407.         /* src = asl(src); AC = ora(src); */
  408.  
  409.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  410.         src <<= 1;
  411.         src |= AC;
  412.         src &= 0xff;
  413.         SET_SIGN (src);
  414.         SET_ZERO (src);
  415.  
  416.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  417.         clkcount = 8;
  418.           }
  419.  
  420.           break;
  421.  
  422.         case 20:
  423.           {
  424.         PC += 2;
  425.  
  426.         clkcount = 4;
  427.           }
  428.  
  429.           break;
  430.  
  431.         case 21:
  432.           {
  433.         register p1 = LOAD (PC + 1);
  434.         register unsigned src = LOAD_ZERO (p1 + XR);
  435.         PC += 2;
  436.  
  437.         src |= AC;
  438.         SET_SIGN (src);
  439.         SET_ZERO (src);
  440.  
  441.         AC = (src);;
  442.         clkcount = 4;
  443.           }
  444.  
  445.           break;
  446.  
  447.         case 22:
  448.           {
  449.         register p1 = LOAD (PC + 1);
  450.         register unsigned src = LOAD_ZERO (p1 + XR);
  451.         PC += 2;
  452.  
  453.         SET_CARRY (src & 0x80);
  454.         src <<= 1;
  455.         src &= 0xff;
  456.         SET_SIGN (src);
  457.         SET_ZERO (src);
  458.  
  459.         STORE_ZERO (p1 + XR, (src));;
  460.         clkcount = 6;
  461.           }
  462.  
  463.           break;
  464.  
  465.         case 23:
  466.           {
  467.         register p1 = LOAD (PC + 1);
  468.         register unsigned src = LOAD_ZERO (p1 + XR);
  469.         PC += 2;
  470.  
  471.         /* src = asl(src); AC = ora(src); */
  472.  
  473.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  474.         src <<= 1;
  475.         src |= AC;
  476.         src &= 0xff;
  477.         SET_SIGN (src);
  478.         SET_ZERO (src);
  479.  
  480.         STORE_ZERO (p1 + XR, (src));;
  481.         clkcount = 6;
  482.           }
  483.  
  484.           break;
  485.  
  486.         case 24:
  487.           {
  488.         PC++;
  489.  
  490.  
  491.         SET_CARRY ((0));;
  492.         clkcount = 2;
  493.           }
  494.  
  495.           break;
  496.  
  497.         case 25:
  498. /*  ORA,    ABSOLUTE_Y */
  499.           {
  500.         register p2 = load_abs_addr ();
  501.         register unsigned src = LOAD (p2 + YR);
  502.         PC += 3;
  503.  
  504.         if (pagetest (p2, YR))
  505.           /* Over page */
  506.           clkcount = 5;
  507.         else
  508.           /* Same page */
  509.           clkcount = 4;
  510.  
  511.         src |= AC;
  512.         SET_SIGN (src);
  513.         SET_ZERO (src);
  514.  
  515.         AC = (src);;
  516.           }
  517.  
  518.           break;
  519.  
  520.         case 26:
  521.           {
  522.         PC++;
  523.  
  524.         clkcount = 2;
  525.           }
  526.  
  527.           break;
  528.  
  529.         case 27:
  530.           {
  531.         register p2 = load_abs_addr ();
  532.         register unsigned src = LOAD (p2 + YR);
  533.         PC += 3;
  534.  
  535.         /* src = asl(src); AC = ora(src); */
  536.  
  537.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  538.         src <<= 1;
  539.         src |= AC;
  540.         src &= 0xff;
  541.         SET_SIGN (src);
  542.         SET_ZERO (src);
  543.  
  544.         STORE (p2 + YR, (src));;
  545.         clkcount = 7;
  546.           }
  547.  
  548.           break;
  549.  
  550.         case 28:
  551.           {
  552.         PC += 3;
  553.  
  554.         clkcount = 4;
  555.           }
  556.  
  557.           break;
  558.  
  559.         case 29:
  560. /*   ORA,    ABSOLUTE_X */
  561.           {
  562.         register p2 = load_abs_addr ();
  563.         register unsigned src = LOAD (p2 + XR);
  564.         PC += 3;
  565.  
  566.         if (pagetest (p2, XR))
  567.           /* Over page */
  568.           clkcount = 5;
  569.         else
  570.           /* Same page */
  571.           clkcount = 4;
  572.  
  573.         src |= AC;
  574.         SET_SIGN (src);
  575.         SET_ZERO (src);
  576.  
  577.         AC = (src);;
  578.           }
  579.  
  580.           break;
  581.  
  582.         case 30:
  583.           {
  584.         register p2 = load_abs_addr ();
  585.         register unsigned src = LOAD (p2 + XR);
  586.         PC += 3;
  587.  
  588.         SET_CARRY (src & 0x80);
  589.         src <<= 1;
  590.         src &= 0xff;
  591.         SET_SIGN (src);
  592.         SET_ZERO (src);
  593.  
  594.         STORE (p2 + XR, (src));;
  595.         clkcount = 7;
  596.           }
  597.  
  598.           break;
  599.  
  600.         case 31:
  601.           {
  602.         register p2 = load_abs_addr ();
  603.         register unsigned src = LOAD (p2 + XR);
  604.         PC += 3;
  605.  
  606.         /* src = asl(src); AC = ora(src); */
  607.  
  608.         SET_CARRY (src & 0x80);        /* ASL+ORA */
  609.         src <<= 1;
  610.         src |= AC;
  611.         src &= 0xff;
  612.         SET_SIGN (src);
  613.         SET_ZERO (src);
  614.  
  615.         STORE (p2 + XR, (src));;
  616.         clkcount = 7;
  617.           }
  618.  
  619.           break;
  620.  
  621.         case 32:
  622.           {
  623.         register p2 = load_abs_addr ();
  624.         register unsigned src = p2;
  625.         PC += 3;
  626.         /* Jump to subroutine. */
  627.         PC--;
  628.         PUSH ((PC >> 8) & 0xff);    /* Push return address onto the stack. */
  629.         PUSH (PC & 0xff);
  630.  
  631.         PC = (src);;
  632.         clkcount = 6;
  633.           }
  634.  
  635.           break;
  636.  
  637.         case 33:
  638.           {
  639.         register p1 = LOAD (PC + 1);
  640.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  641.         PC += 2;
  642.  
  643.         src &= AC;
  644.         SET_SIGN (src);
  645.         SET_ZERO (src);
  646.  
  647.         AC = (src);;
  648.         clkcount = 6;
  649.           }
  650.  
  651.           break;
  652.  
  653.         case 35:
  654.           {
  655.         register p1 = LOAD (PC + 1);
  656.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  657.         PC += 2;
  658.  
  659.         /* src = rol(src); AC = and(src); */
  660.  
  661.         src <<= 1;
  662.         if (IF_CARRY ())    /* ROL+AND */
  663.           src |= 0x1;
  664.         SET_CARRY (src > 0xff);
  665.         src &= 0xff;
  666.  
  667.         AC &= src;
  668.         SET_SIGN (AC);
  669.         SET_ZERO (AC);
  670.         /* rotated, not disturbed */
  671.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  672.         clkcount = 8;
  673.           }
  674.  
  675.           break;
  676.  
  677.         case 36:
  678.           {
  679.         register p1 = LOAD (PC + 1);
  680.         register unsigned src = LOAD_ZERO (p1);
  681.         PC += 2;
  682.  
  683.         SET_SIGN (src);
  684.         SET_OVERFLOW (0x40 & src);    /* Copy bit 6 to OVERFLOW flag. */
  685.         SET_ZERO (src & AC);
  686.         clkcount = 3;
  687.           }
  688.  
  689.           break;
  690.  
  691.         case 37:
  692.           {
  693.         register p1 = LOAD (PC + 1);
  694.         register unsigned src = LOAD_ZERO (p1);
  695.         PC += 2;
  696.  
  697.         src &= AC;
  698.         SET_SIGN (src);
  699.         SET_ZERO (src);
  700.  
  701.         AC = (src);;
  702.         clkcount = 3;
  703.           }
  704.  
  705.           break;
  706.  
  707.         case 38:
  708.           {
  709.         register p1 = LOAD (PC + 1);
  710.         register unsigned src = LOAD_ZERO (p1);
  711.         PC += 2;
  712.  
  713.         src <<= 1;
  714.         if (IF_CARRY ())
  715.           src |= 0x1;
  716.         SET_CARRY (src > 0xff);
  717.         src &= 0xff;
  718.         SET_SIGN (src);
  719.         SET_ZERO (src);
  720.  
  721.         STORE_ZERO (p1, (src));;
  722.         clkcount = 5;
  723.           }
  724.  
  725.           break;
  726.  
  727.         case 39:
  728.           {
  729.         register p1 = LOAD (PC + 1);
  730.         register unsigned src = LOAD_ZERO (p1);
  731.         PC += 2;
  732.  
  733.         /* src = rol(src); AC = and(src); */
  734.  
  735.         src <<= 1;
  736.         if (IF_CARRY ())    /* ROL+AND */
  737.           src |= 0x1;
  738.         SET_CARRY (src > 0xff);
  739.         src &= 0xff;
  740.  
  741.         AC &= src;
  742.         SET_SIGN (AC);
  743.         SET_ZERO (AC);
  744.         /* rotated, not disturbed */
  745.         STORE_ZERO (p1, (src));;
  746.         clkcount = 5;
  747.           }
  748.  
  749.           break;
  750.  
  751.         case 40:
  752.           {
  753.         register unsigned src;
  754.         PC++;
  755.  
  756.         /* First increment stack pointer and then pull item from stack. */
  757.         src = PULL ();
  758.  
  759.         SET_SR ((src));;
  760.         clkcount = 4;
  761.           }
  762.  
  763.           break;
  764.  
  765.         case 41:
  766.           {
  767.         register p1 = LOAD (PC + 1);
  768.         register unsigned src = p1;
  769.         PC += 2;
  770.  
  771.         src &= AC;
  772.         SET_SIGN (src);
  773.         SET_ZERO (src);
  774.  
  775.         AC = (src);;
  776.         clkcount = 2;
  777.           }
  778.  
  779.           break;
  780.  
  781.         case 42:
  782.           {
  783.         register unsigned src = AC;
  784.         PC++;
  785.  
  786.         src <<= 1;
  787.         if (IF_CARRY ())
  788.           src |= 0x1;
  789.         SET_CARRY (src > 0xff);
  790.         src &= 0xff;
  791.         SET_SIGN (src);
  792.         SET_ZERO (src);
  793.  
  794.         AC = (src);;
  795.         clkcount = 2;
  796.           }
  797.  
  798.           break;
  799.  
  800.         case 43:
  801.           {
  802.         register p1 = LOAD (PC + 1);
  803.         register unsigned src = (AC & p1);
  804.         PC += 2;
  805.  
  806.         src &= AC;
  807.         SET_SIGN (src);
  808.         SET_ZERO (src);
  809.  
  810.         AC = (src);;
  811.         clkcount = 2;
  812.           }
  813.  
  814.           break;
  815.  
  816.         case 44:
  817.           {
  818.         register p2 = load_abs_addr ();
  819.         register unsigned src = LOAD (p2);
  820.         PC += 3;
  821.  
  822.         SET_SIGN (src);
  823.         SET_OVERFLOW (0x40 & src);    /* Copy bit 6 to OVERFLOW flag. */
  824.         SET_ZERO (src & AC);
  825.         clkcount = 4;
  826.           }
  827.  
  828.           break;
  829.  
  830.         case 45:
  831.           {
  832.         register p2 = load_abs_addr ();
  833.         register unsigned src = LOAD (p2);
  834.         PC += 3;
  835.  
  836.         src &= AC;
  837.         SET_SIGN (src);
  838.         SET_ZERO (src);
  839.  
  840.         AC = (src);;
  841.         clkcount = 4;
  842.           }
  843.  
  844.           break;
  845.  
  846.         case 46:
  847.           {
  848.         register p2 = load_abs_addr ();
  849.         register unsigned src = LOAD (p2);
  850.         PC += 3;
  851.  
  852.         src <<= 1;
  853.         if (IF_CARRY ())
  854.           src |= 0x1;
  855.         SET_CARRY (src > 0xff);
  856.         src &= 0xff;
  857.         SET_SIGN (src);
  858.         SET_ZERO (src);
  859.  
  860.         STORE (p2, (src));;
  861.         clkcount = 6;
  862.           }
  863.  
  864.           break;
  865.  
  866.         case 47:
  867.           {
  868.         register p2 = load_abs_addr ();
  869.         register unsigned src = LOAD (p2);
  870.         PC += 3;
  871.  
  872.         /* src = rol(src); AC = and(src); */
  873.  
  874.         src <<= 1;
  875.         if (IF_CARRY ())    /* ROL+AND */
  876.           src |= 0x1;
  877.         SET_CARRY (src > 0xff);
  878.         src &= 0xff;
  879.  
  880.         AC &= src;
  881.         SET_SIGN (AC);
  882.         SET_ZERO (AC);
  883.         /* rotated, not disturbed */
  884.         STORE (p2, (src));;
  885.         clkcount = 6;
  886.           }
  887.  
  888.           break;
  889.  
  890.         case 48:
  891. /*   BMI,    RELATIVE */
  892.           {
  893.         register p1 = LOAD (PC + 1);
  894.         register unsigned src = p1;
  895.         register UBYTE hb;
  896.         PC += 2;
  897.         /* Branch if sign flag is set. */
  898.         if (IF_SIGN ())
  899.           {
  900.             hb = UPPER (PC);
  901.             PC = REL_ADDR (PC, src);
  902.             if (brtest (hb))
  903.               /* Same page */
  904.               clkcount = 3;
  905.             else
  906.               /* Different page */
  907.               clkcount = 4;
  908.           }
  909.         else
  910.           clkcount = 2;
  911.           }
  912.  
  913.           break;
  914.  
  915.         case 49:
  916. /*  AND,    INDIRECT_Y */
  917.           {
  918.         register p1 = LOAD (PC + 1);
  919.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  920.         register unsigned src = LOAD (p2 + YR);
  921.         PC += 2;
  922.         if (pagetest (p2, YR))
  923.           /* Over page */
  924.           clkcount = 6;
  925.         else
  926.           /* Same page */
  927.           clkcount = 5;
  928.  
  929.         src &= AC;
  930.         SET_SIGN (src);
  931.         SET_ZERO (src);
  932.  
  933.         AC = (src);;
  934.           }
  935.  
  936.           break;
  937.  
  938.         case 51:
  939.           {
  940.         register p1 = LOAD (PC + 1);
  941.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  942.         PC += 2;
  943.  
  944.         /* src = rol(src); AC = and(src); */
  945.  
  946.         src <<= 1;
  947.         if (IF_CARRY ())    /* ROL+AND */
  948.           src |= 0x1;
  949.         SET_CARRY (src > 0xff);
  950.         src &= 0xff;
  951.  
  952.         AC &= src;
  953.         SET_SIGN (AC);
  954.         SET_ZERO (AC);
  955.         /* rotated, not disturbed */
  956.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  957.         clkcount = 8;
  958.           }
  959.  
  960.           break;
  961.  
  962.         case 52:
  963.           {
  964.         PC += 2;
  965.  
  966.         clkcount = 4;
  967.           }
  968.  
  969.           break;
  970.  
  971.         case 53:
  972.           {
  973.         register p1 = LOAD (PC + 1);
  974.         register unsigned src = LOAD_ZERO (p1 + XR);
  975.         PC += 2;
  976.  
  977.         src &= AC;
  978.         SET_SIGN (src);
  979.         SET_ZERO (src);
  980.  
  981.         AC = (src);;
  982.         clkcount = 4;
  983.           }
  984.  
  985.           break;
  986.  
  987.         case 54:
  988.           {
  989.         register p1 = LOAD (PC + 1);
  990.         register unsigned src = LOAD_ZERO (p1 + XR);
  991.         PC += 2;
  992.  
  993.         src <<= 1;
  994.         if (IF_CARRY ())
  995.           src |= 0x1;
  996.         SET_CARRY (src > 0xff);
  997.         src &= 0xff;
  998.         SET_SIGN (src);
  999.         SET_ZERO (src);
  1000.  
  1001.         STORE_ZERO (p1 + XR, (src));;
  1002.         clkcount = 6;
  1003.           }
  1004.  
  1005.           break;
  1006.  
  1007.         case 55:
  1008.           {
  1009.         register p1 = LOAD (PC + 1);
  1010.         register unsigned src = LOAD_ZERO (p1 + XR);
  1011.         PC += 2;
  1012.  
  1013.         /* src = rol(src); AC = and(src); */
  1014.  
  1015.         src <<= 1;
  1016.         if (IF_CARRY ())    /* ROL+AND */
  1017.           src |= 0x1;
  1018.         SET_CARRY (src > 0xff);
  1019.         src &= 0xff;
  1020.  
  1021.         AC &= src;
  1022.         SET_SIGN (AC);
  1023.         SET_ZERO (AC);
  1024.         /* rotated, not disturbed */
  1025.         STORE_ZERO (p1 + XR, (src));;
  1026.         clkcount = 6;
  1027.           }
  1028.  
  1029.           break;
  1030.  
  1031.         case 56:
  1032.           {
  1033.         PC++;
  1034.  
  1035.  
  1036.         SET_CARRY ((1));;
  1037.         clkcount = 2;
  1038.           }
  1039.  
  1040.           break;
  1041.  
  1042.         case 57:
  1043. /*  AND,    ABSOLUTE_Y */
  1044.           {
  1045.         register p2 = load_abs_addr ();
  1046.         register unsigned src = LOAD (p2 + YR);
  1047.         PC += 3;
  1048.         if (pagetest (p2, YR))
  1049.           /* Over page */
  1050.           clkcount = 5;
  1051.         else
  1052.           /* Same page */
  1053.           clkcount = 4;
  1054.         src &= AC;
  1055.         SET_SIGN (src);
  1056.         SET_ZERO (src);
  1057.  
  1058.         AC = (src);
  1059.           }
  1060.  
  1061.           break;
  1062.  
  1063.         case 58:
  1064.           {
  1065.         PC++;
  1066.  
  1067.         clkcount = 2;
  1068.           }
  1069.  
  1070.           break;
  1071.  
  1072.         case 59:
  1073.           {
  1074.         register p2 = load_abs_addr ();
  1075.         register unsigned src = LOAD (p2 + YR);
  1076.         PC += 3;
  1077.  
  1078.         /* src = rol(src); AC = and(src); */
  1079.  
  1080.         src <<= 1;
  1081.         if (IF_CARRY ())    /* ROL+AND */
  1082.           src |= 0x1;
  1083.         SET_CARRY (src > 0xff);
  1084.         src &= 0xff;
  1085.  
  1086.         AC &= src;
  1087.         SET_SIGN (AC);
  1088.         SET_ZERO (AC);
  1089.         /* rotated, not disturbed */
  1090.         STORE (p2 + YR, (src));;
  1091.         clkcount = 7;
  1092.           }
  1093.  
  1094.           break;
  1095.  
  1096.         case 60:
  1097.           {
  1098.         PC += 3;
  1099.  
  1100.         clkcount = 4;
  1101.           }
  1102.  
  1103.           break;
  1104.  
  1105.         case 61:
  1106. /*   AND,    ABSOLUTE_X */
  1107.           {
  1108.         register p2 = load_abs_addr ();
  1109.         register unsigned src = LOAD (p2 + XR);
  1110.         PC += 3;
  1111.         if (pagetest (p2, XR))
  1112.           /* Over page */
  1113.           clkcount = 5;
  1114.         else
  1115.           /* Same page */
  1116.           clkcount = 4;
  1117.         src &= AC;
  1118.         SET_SIGN (src);
  1119.         SET_ZERO (src);
  1120.  
  1121.         AC = (src);;
  1122.           }
  1123.  
  1124.           break;
  1125.  
  1126.         case 62:
  1127.           {
  1128.         register p2 = load_abs_addr ();
  1129.         register unsigned src = LOAD (p2 + XR);
  1130.         PC += 3;
  1131.  
  1132.         src <<= 1;
  1133.         if (IF_CARRY ())
  1134.           src |= 0x1;
  1135.         SET_CARRY (src > 0xff);
  1136.         src &= 0xff;
  1137.         SET_SIGN (src);
  1138.         SET_ZERO (src);
  1139.  
  1140.         STORE (p2 + XR, (src));;
  1141.         clkcount = 7;
  1142.           }
  1143.  
  1144.           break;
  1145.  
  1146.         case 63:
  1147.           {
  1148.         register p2 = load_abs_addr ();
  1149.         register unsigned src = LOAD (p2 + XR);
  1150.         PC += 3;
  1151.  
  1152.         /* src = rol(src); AC = and(src); */
  1153.  
  1154.         src <<= 1;
  1155.         if (IF_CARRY ())    /* ROL+AND */
  1156.           src |= 0x1;
  1157.         SET_CARRY (src > 0xff);
  1158.         src &= 0xff;
  1159.  
  1160.         AC &= src;
  1161.         SET_SIGN (AC);
  1162.         SET_ZERO (AC);
  1163.         /* rotated, not disturbed */
  1164.         STORE (p2 + XR, (src));;
  1165.         clkcount = 7;
  1166.           }
  1167.  
  1168.           break;
  1169.  
  1170.         case 64:
  1171.           {
  1172.         register unsigned src;
  1173.         PC++;
  1174.         /* Return from interrupt. */
  1175.         /* Load program status and program counter from stack. */
  1176.         src = PULL ();
  1177.         SET_SR (src);
  1178.         src = PULL ();
  1179.         src |= (PULL () << 8);    /* Load return address from stack. */
  1180.  
  1181.         PC = (src);;
  1182.         clkcount = 6;
  1183.           }
  1184.  
  1185.           break;
  1186.  
  1187.         case 65:
  1188.           {
  1189.         register p1 = LOAD (PC + 1);
  1190.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  1191.         PC += 2;
  1192.  
  1193.         src ^= AC;
  1194.         SET_SIGN (src);
  1195.         SET_ZERO (src);
  1196.  
  1197.         AC = (src & 0xff);;
  1198.         clkcount = 6;
  1199.           }
  1200.  
  1201.           break;
  1202.  
  1203.         case 67:
  1204.           {
  1205.         register p1 = LOAD (PC + 1);
  1206.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  1207.         PC += 2;
  1208.  
  1209.         /* src = lsr(src); AC = eor(src); */
  1210.  
  1211.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1212.         src >>= 1;
  1213.         src ^= AC;
  1214.         src &= 0xff;
  1215.         SET_SIGN (src);
  1216.         SET_ZERO (src);
  1217.  
  1218.  
  1219.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  1220.         clkcount = 8;
  1221.           }
  1222.  
  1223.           break;
  1224.  
  1225.         case 68:
  1226.           {
  1227.         PC += 2;
  1228.  
  1229.         clkcount = 3;
  1230.           }
  1231.  
  1232.           break;
  1233.  
  1234.         case 69:
  1235.           {
  1236.         register p1 = LOAD (PC + 1);
  1237.         register unsigned src = LOAD_ZERO (p1);
  1238.         PC += 2;
  1239.  
  1240.         src ^= AC;
  1241.         SET_SIGN (src);
  1242.         SET_ZERO (src);
  1243.  
  1244.         AC = (src & 0xff);;
  1245.         clkcount = 3;
  1246.           }
  1247.  
  1248.           break;
  1249.  
  1250.         case 70:
  1251.           {
  1252.         register p1 = LOAD (PC + 1);
  1253.         register unsigned src = LOAD_ZERO (p1);
  1254.         PC += 2;
  1255.  
  1256.         SET_CARRY (src & 0x01);
  1257.         src >>= 1;
  1258.  
  1259.         SET_SIGN (src);
  1260.         SET_ZERO (src);
  1261.  
  1262.         STORE_ZERO (p1, (src));;
  1263.         clkcount = 5;
  1264.           }
  1265.  
  1266.           break;
  1267.  
  1268.         case 71:
  1269.           {
  1270.         register p1 = LOAD (PC + 1);
  1271.         register unsigned src = LOAD_ZERO (p1);
  1272.         PC += 2;
  1273.  
  1274.         /* src = lsr(src); AC = eor(src); */
  1275.  
  1276.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1277.         src >>= 1;
  1278.         src ^= AC;
  1279.         src &= 0xff;
  1280.         SET_SIGN (src);
  1281.         SET_ZERO (src);
  1282.  
  1283.  
  1284.         STORE_ZERO (p1, (src));;
  1285.         clkcount = 5;
  1286.           }
  1287.  
  1288.           break;
  1289.  
  1290.         case 72:
  1291. /*   PHA,    IMPLIED */
  1292.           {
  1293.         register unsigned src = AC;
  1294.         PC++;
  1295.  
  1296.         beamadj = BEAMNINE;
  1297.         PUSH (src);
  1298.         /* First push item onto stack and then decrement SP. */
  1299.         clkcount = 3;
  1300.           }
  1301.  
  1302.           break;
  1303.  
  1304.         case 73:
  1305.           {
  1306.         register p1 = LOAD (PC + 1);
  1307.         register unsigned src = p1;
  1308.         PC += 2;
  1309.  
  1310.         src ^= AC;
  1311.         SET_SIGN (src);
  1312.         SET_ZERO (src);
  1313.  
  1314.         AC = (src & 0xff);;
  1315.         clkcount = 2;
  1316.           }
  1317.  
  1318.           break;
  1319.  
  1320.         case 74:
  1321.           {
  1322.         register unsigned src = AC;
  1323.         PC++;
  1324.  
  1325.         SET_CARRY (src & 0x01);
  1326.         src >>= 1;
  1327.  
  1328.         SET_SIGN (src);
  1329.         SET_ZERO (src);
  1330.  
  1331.         AC = (src);;
  1332.         clkcount = 2;
  1333.           }
  1334.  
  1335.           break;
  1336.  
  1337.         case 75:
  1338.           {
  1339.         register p1 = LOAD (PC + 1);
  1340.         register unsigned src = (AC & p1);
  1341.         PC += 2;
  1342.  
  1343.         SET_CARRY (src & 0x01);
  1344.         src >>= 1;
  1345.  
  1346.         SET_SIGN (src);
  1347.         SET_ZERO (src);
  1348.  
  1349.         AC = (src);;
  1350.         clkcount = 2;
  1351.           }
  1352.  
  1353.           break;
  1354.  
  1355.         case 76:
  1356.           {
  1357.         register p2 = load_abs_addr ();
  1358.         register unsigned src = p2;
  1359.         PC += 3;
  1360.  
  1361.  
  1362.         PC = (src);;
  1363.         clkcount = 3;
  1364.           }
  1365.  
  1366.           break;
  1367.  
  1368.         case 77:
  1369.           {
  1370.         register p2 = load_abs_addr ();
  1371.         register unsigned src = LOAD (p2);
  1372.         PC += 3;
  1373.  
  1374.         src ^= AC;
  1375.         SET_SIGN (src);
  1376.         SET_ZERO (src);
  1377.  
  1378.         AC = (src & 0xff);;
  1379.         clkcount = 4;
  1380.           }
  1381.  
  1382.           break;
  1383.  
  1384.         case 78:
  1385.           {
  1386.         register p2 = load_abs_addr ();
  1387.         register unsigned src = LOAD (p2);
  1388.         PC += 3;
  1389.  
  1390.         SET_CARRY (src & 0x01);
  1391.         src >>= 1;
  1392.  
  1393.         SET_SIGN (src);
  1394.         SET_ZERO (src);
  1395.  
  1396.         STORE (p2, (src));;
  1397.         clkcount = 6;
  1398.           }
  1399.  
  1400.           break;
  1401.  
  1402.         case 79:
  1403.           {
  1404.         register p2 = load_abs_addr ();
  1405.         register unsigned src = LOAD (p2);
  1406.         PC += 3;
  1407.  
  1408.         /* src = lsr(src); AC = eor(src); */
  1409.  
  1410.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1411.         src >>= 1;
  1412.         src ^= AC;
  1413.         src &= 0xff;
  1414.         SET_SIGN (src);
  1415.         SET_ZERO (src);
  1416.  
  1417.  
  1418.         STORE (p2, (src));;
  1419.         clkcount = 6;
  1420.           }
  1421.  
  1422.           break;
  1423.  
  1424.         case 80:
  1425. /*   BVC,    RELATIVE */
  1426.           {
  1427.         register p1 = LOAD (PC + 1);
  1428.         register unsigned src = p1;
  1429.         register UBYTE hb;
  1430.         PC += 2;
  1431.         /* Branch if overflow flag is clear. */
  1432.         if (!IF_OVERFLOW ())
  1433.           {
  1434.             hb = UPPER (PC);
  1435.             PC = REL_ADDR (PC, src);
  1436.             if (brtest (hb))
  1437.               /* Same page */
  1438.               clkcount = 3;
  1439.             else
  1440.               /* Different page */
  1441.               clkcount = 4;
  1442.           }
  1443.         else
  1444.           clkcount = 2;
  1445.           }
  1446.  
  1447.           break;
  1448.  
  1449.         case 81:
  1450. /* EOR,    INDIRECT_Y */
  1451.           {
  1452.         register p1 = LOAD (PC + 1);
  1453.         register p2 = LOAD_ZERO_ADDR (p1);
  1454.         register unsigned src = LOAD (p2 + YR);
  1455.         PC += 2;
  1456.         if (pagetest (p2, YR))
  1457.           /* Over page */
  1458.           clkcount = 6;
  1459.         else
  1460.           /* Same page */
  1461.           clkcount = 5;
  1462.  
  1463.         src ^= AC;
  1464.         SET_SIGN (src);
  1465.         SET_ZERO (src);
  1466.  
  1467.         AC = (src & 0xff);;
  1468.           }
  1469.  
  1470.           break;
  1471.  
  1472.         case 83:
  1473.           {
  1474.         register p1 = LOAD (PC + 1);
  1475.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  1476.         PC += 2;
  1477.  
  1478.         /* src = lsr(src); AC = eor(src); */
  1479.  
  1480.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1481.         src >>= 1;
  1482.         src ^= AC;
  1483.         src &= 0xff;
  1484.         SET_SIGN (src);
  1485.         SET_ZERO (src);
  1486.  
  1487.  
  1488.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  1489.         clkcount = 8;
  1490.           }
  1491.  
  1492.           break;
  1493.  
  1494.         case 84:
  1495.           {
  1496.         PC += 2;
  1497.  
  1498.         clkcount = 4;
  1499.           }
  1500.  
  1501.           break;
  1502.  
  1503.         case 85:
  1504.           {
  1505.         register p1 = LOAD (PC + 1);
  1506.         register unsigned src = LOAD_ZERO (p1 + XR);
  1507.         PC += 2;
  1508.  
  1509.         src ^= AC;
  1510.         SET_SIGN (src);
  1511.         SET_ZERO (src);
  1512.  
  1513.         AC = (src & 0xff);;
  1514.         clkcount = 4;
  1515.           }
  1516.  
  1517.           break;
  1518.  
  1519.         case 86:
  1520.           {
  1521.         register p1 = LOAD (PC + 1);
  1522.         register unsigned src = LOAD_ZERO (p1 + XR);
  1523.         PC += 2;
  1524.  
  1525.         SET_CARRY (src & 0x01);
  1526.         src >>= 1;
  1527.  
  1528.         SET_SIGN (src);
  1529.         SET_ZERO (src);
  1530.  
  1531.         STORE_ZERO (p1 + XR, (src));;
  1532.         clkcount = 6;
  1533.           }
  1534.  
  1535.           break;
  1536.  
  1537.         case 87:
  1538.           {
  1539.         register p1 = LOAD (PC + 1);
  1540.         register unsigned src = LOAD_ZERO (p1 + XR);
  1541.         PC += 2;
  1542.  
  1543.         /* src = lsr(src); AC = eor(src); */
  1544.  
  1545.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1546.         src >>= 1;
  1547.         src ^= AC;
  1548.         src &= 0xff;
  1549.         SET_SIGN (src);
  1550.         SET_ZERO (src);
  1551.  
  1552.  
  1553.         STORE_ZERO (p1 + XR, (src));;
  1554.         clkcount = 6;
  1555.           }
  1556.  
  1557.           break;
  1558.  
  1559.         case 88:
  1560.           {
  1561.         PC++;
  1562.  
  1563.  
  1564.         SET_INTERRUPT ((0));;
  1565.         clkcount = 2;
  1566.           }
  1567.  
  1568.           break;
  1569.  
  1570.         case 89:
  1571. /*  EOR,    ABSOLUTE_Y */
  1572.           {
  1573.         register p2 = load_abs_addr ();
  1574.         register unsigned src = LOAD (p2 + YR);
  1575.         PC += 3;
  1576.         if (pagetest (p2, YR))
  1577.           /* Over page */
  1578.           clkcount = 5;
  1579.         else
  1580.           /* Same page */
  1581.           clkcount = 4;
  1582.  
  1583.         src ^= AC;
  1584.         SET_SIGN (src);
  1585.         SET_ZERO (src);
  1586.  
  1587.         AC = (src & 0xff);
  1588.           }
  1589.  
  1590.           break;
  1591.  
  1592.         case 90:
  1593.           {
  1594.         PC++;
  1595.  
  1596.         clkcount = 2;
  1597.           }
  1598.  
  1599.           break;
  1600.  
  1601.         case 91:
  1602.           {
  1603.         register p2 = load_abs_addr ();
  1604.         register unsigned src = LOAD (p2 + YR);
  1605.         PC += 3;
  1606.  
  1607.         /* src = lsr(src); AC = eor(src); */
  1608.  
  1609.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1610.         src >>= 1;
  1611.         src ^= AC;
  1612.         src &= 0xff;
  1613.         SET_SIGN (src);
  1614.         SET_ZERO (src);
  1615.  
  1616.  
  1617.         STORE (p2 + YR, (src));;
  1618.         clkcount = 7;
  1619.           }
  1620.  
  1621.           break;
  1622.  
  1623.         case 92:
  1624.           {
  1625.         PC += 3;
  1626.  
  1627.         clkcount = 4;
  1628.           }
  1629.  
  1630.           break;
  1631.  
  1632.         case 93:
  1633. /*  EOR,    ABSOLUTE_X */
  1634.           {
  1635.         register p2 = load_abs_addr ();
  1636.         register unsigned src = LOAD (p2 + XR);
  1637.         PC += 3;
  1638.         if (pagetest (p2, XR))
  1639.           /* Over page */
  1640.           clkcount = 5;
  1641.         else
  1642.           /* Same page */
  1643.           clkcount = 4;
  1644.  
  1645.         src ^= AC;
  1646.         SET_SIGN (src);
  1647.         SET_ZERO (src);
  1648.  
  1649.         AC = (src & 0xff);;
  1650.           }
  1651.  
  1652.           break;
  1653.  
  1654.         case 94:
  1655.           {
  1656.         register p2 = load_abs_addr ();
  1657.         register unsigned src = LOAD (p2 + XR);
  1658.         PC += 3;
  1659.  
  1660.         SET_CARRY (src & 0x01);
  1661.         src >>= 1;
  1662.  
  1663.         SET_SIGN (src);
  1664.         SET_ZERO (src);
  1665.  
  1666.         STORE (p2 + XR, (src));;
  1667.         clkcount = 7;
  1668.           }
  1669.  
  1670.           break;
  1671.  
  1672.         case 95:
  1673.           {
  1674.         register p2 = load_abs_addr ();
  1675.         register unsigned src = LOAD (p2 + XR);
  1676.         PC += 3;
  1677.  
  1678.         /* src = lsr(src); AC = eor(src); */
  1679.  
  1680.         SET_CARRY (src & 0x01);        /* LSR+EOR */
  1681.         src >>= 1;
  1682.         src ^= AC;
  1683.         src &= 0xff;
  1684.         SET_SIGN (src);
  1685.         SET_ZERO (src);
  1686.  
  1687.  
  1688.         STORE (p2 + XR, (src));;
  1689.         clkcount = 7;
  1690.           }
  1691.  
  1692.           break;
  1693.  
  1694.         case 96:
  1695.           {
  1696.         register unsigned src;
  1697.         PC++;
  1698.         /* Return from subroutine. */
  1699.         src = PULL ();
  1700.         src += ((PULL ()) << 8) + 1;    /* Load return address from stack and add 1. */
  1701.  
  1702.         PC = (src);;
  1703.         clkcount = 6;
  1704.           }
  1705.  
  1706.           break;
  1707.  
  1708.         case 97:
  1709.           {
  1710.         register p1 = LOAD (PC + 1);
  1711.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  1712.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  1713.         PC += 2;
  1714.  
  1715.  
  1716.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  1717.  
  1718.         /*
  1719.          * In decimal mode this is "correct" but not exact emulation. However,
  1720.          * the probability of different result when using undefined BCD codes is
  1721.          * less than 6%
  1722.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  1723.          */
  1724.  
  1725.         if (IF_DECIMAL ())
  1726.           {
  1727.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  1728.               temp += 6;
  1729.  
  1730.             SET_SIGN (temp);
  1731.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1732.  
  1733.             if (temp > 0x99)
  1734.               temp += 96;
  1735.  
  1736.             SET_CARRY (temp > 0x99);
  1737.           }
  1738.         else
  1739.           {
  1740.             SET_SIGN (temp);
  1741.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1742.             SET_CARRY (temp > 0xff);
  1743.           }
  1744.  
  1745.         AC = ((UBYTE) temp);;
  1746.         clkcount = 6;
  1747.           }
  1748.  
  1749.           break;
  1750.  
  1751.         case 99:
  1752.           {
  1753.         register p1 = LOAD (PC + 1);
  1754.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  1755.         register unsigned int temp;
  1756.         PC += 2;
  1757.  
  1758.  
  1759.         /* src = ror(src); AC = adc(src);
  1760.          * the real operation discovered by msmakela
  1761.          * ADC only does the BCD fixup */
  1762.  
  1763.         temp = src >> 1;    /* ROR+ADC */
  1764.         if (IF_CARRY ())
  1765.           temp |= 0x80;
  1766.  
  1767.         SET_SIGN (temp);
  1768.         SET_ZERO (temp);    /* Set flags like ROR does */
  1769.  
  1770.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  1771.  
  1772.         if (IF_DECIMAL ())
  1773.           {
  1774.             if ((src & 0x0f) > 4)    /* half of the normal */
  1775.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  1776.             if (src > 0x4f)
  1777.               temp += 96;
  1778.  
  1779.             SET_CARRY (src > 0x4f);
  1780.           }
  1781.         else
  1782.           {
  1783.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  1784.           }
  1785.  
  1786.  
  1787.         STORE (LOAD_ZERO_ADDR (p1 + XR), ((UBYTE) temp));;
  1788.         clkcount = 8;
  1789.           }
  1790.  
  1791.           break;
  1792.  
  1793.         case 100:
  1794.           {
  1795.         PC += 2;
  1796.  
  1797.         clkcount = 3;
  1798.           }
  1799.  
  1800.           break;
  1801.  
  1802.         case 101:
  1803.           {
  1804.         register p1 = LOAD (PC + 1);
  1805.         register unsigned src = LOAD_ZERO (p1);
  1806.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  1807.         PC += 2;
  1808.  
  1809.  
  1810.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  1811.  
  1812.         /*
  1813.          * In decimal mode this is "correct" but not exact emulation. However,
  1814.          * the probability of different result when using undefined BCD codes is
  1815.          * less than 6%
  1816.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  1817.          */
  1818.  
  1819.         if (IF_DECIMAL ())
  1820.           {
  1821.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  1822.               temp += 6;
  1823.  
  1824.             SET_SIGN (temp);
  1825.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1826.  
  1827.             if (temp > 0x99)
  1828.               temp += 96;
  1829.  
  1830.             SET_CARRY (temp > 0x99);
  1831.           }
  1832.         else
  1833.           {
  1834.             SET_SIGN (temp);
  1835.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1836.             SET_CARRY (temp > 0xff);
  1837.           }
  1838.  
  1839.         AC = ((UBYTE) temp);;
  1840.         clkcount = 3;
  1841.           }
  1842.  
  1843.           break;
  1844.  
  1845.         case 102:
  1846.           {
  1847.         register p1 = LOAD (PC + 1);
  1848.         register unsigned src = LOAD_ZERO (p1);
  1849.         PC += 2;
  1850.  
  1851.         if (IF_CARRY ())
  1852.           src |= 0x100;
  1853.         SET_CARRY (src & 0x01);
  1854.         src >>= 1;
  1855.  
  1856.         SET_SIGN (src);
  1857.         SET_ZERO (src);
  1858.  
  1859.         STORE_ZERO (p1, (src));;
  1860.         clkcount = 5;
  1861.           }
  1862.  
  1863.           break;
  1864.  
  1865.         case 103:
  1866.           {
  1867.         register p1 = LOAD (PC + 1);
  1868.         register unsigned src = LOAD_ZERO (p1);
  1869.         register unsigned int temp;
  1870.         PC += 2;
  1871.  
  1872.  
  1873.         /* src = ror(src); AC = adc(src);
  1874.          * the real operation discovered by msmakela
  1875.          * ADC only does the BCD fixup */
  1876.  
  1877.         temp = src >> 1;    /* ROR+ADC */
  1878.         if (IF_CARRY ())
  1879.           temp |= 0x80;
  1880.  
  1881.         SET_SIGN (temp);
  1882.         SET_ZERO (temp);    /* Set flags like ROR does */
  1883.  
  1884.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  1885.  
  1886.         if (IF_DECIMAL ())
  1887.           {
  1888.             if ((src & 0x0f) > 4)    /* half of the normal */
  1889.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  1890.             if (src > 0x4f)
  1891.               temp += 96;
  1892.  
  1893.             SET_CARRY (src > 0x4f);
  1894.           }
  1895.         else
  1896.           {
  1897.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  1898.           }
  1899.  
  1900.  
  1901.         STORE_ZERO (p1, ((UBYTE) temp));;
  1902.         clkcount = 5;
  1903.           }
  1904.  
  1905.           break;
  1906.  
  1907.         case 104:
  1908. /*   PLA,    IMPLIED */
  1909.           {
  1910.         register unsigned src;
  1911.         PC++;
  1912.  
  1913.         clkcount = 4;
  1914.         /* First increment stack pointer and then pull item from stack. */
  1915.         src = PULL ();
  1916.         SET_SIGN (src);    /* Change sign and zero flag accordingly. */
  1917.         SET_ZERO (src);
  1918.  
  1919.         AC = (src);
  1920.           }
  1921.  
  1922.           break;
  1923.  
  1924.         case 105:
  1925.           {
  1926.         register p1 = LOAD (PC + 1);
  1927.         register unsigned src = p1;
  1928.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  1929.         PC += 2;
  1930.  
  1931.  
  1932.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  1933.  
  1934.         /*
  1935.          * In decimal mode this is "correct" but not exact emulation. However,
  1936.          * the probability of different result when using undefined BCD codes is
  1937.          * less than 6%
  1938.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  1939.          */
  1940.  
  1941.         if (IF_DECIMAL ())
  1942.           {
  1943.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  1944.               temp += 6;
  1945.  
  1946.             SET_SIGN (temp);
  1947.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1948.  
  1949.             if (temp > 0x99)
  1950.               temp += 96;
  1951.  
  1952.             SET_CARRY (temp > 0x99);
  1953.           }
  1954.         else
  1955.           {
  1956.             SET_SIGN (temp);
  1957.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  1958.             SET_CARRY (temp > 0xff);
  1959.           }
  1960.  
  1961.         AC = ((UBYTE) temp);;
  1962.         clkcount = 2;
  1963.           }
  1964.  
  1965.           break;
  1966.  
  1967.         case 106:
  1968.           {
  1969.         register unsigned src = AC;
  1970.         PC++;
  1971.  
  1972.         if (IF_CARRY ())
  1973.           src |= 0x100;
  1974.         SET_CARRY (src & 0x01);
  1975.         src >>= 1;
  1976.  
  1977.         SET_SIGN (src);
  1978.         SET_ZERO (src);
  1979.  
  1980.         AC = (src);;
  1981.         clkcount = 2;
  1982.           }
  1983.  
  1984.           break;
  1985.  
  1986.         case 107:
  1987.           {
  1988.         register p1 = LOAD (PC + 1);
  1989.         register unsigned src = (AC & p1);
  1990.         PC += 2;
  1991.  
  1992.         if (IF_CARRY ())
  1993.           src |= 0x100;
  1994.         SET_CARRY (src & 0x01);
  1995.         src >>= 1;
  1996.  
  1997.         SET_SIGN (src);
  1998.         SET_ZERO (src);
  1999.  
  2000.         AC = (src);;
  2001.         clkcount = 2;
  2002.           }
  2003.  
  2004.           break;
  2005.  
  2006.         case 108:
  2007.           {
  2008.         register p2 = load_abs_addr ();
  2009.         register unsigned src = LOAD_ADDR (p2);
  2010.         PC += 3;
  2011.  
  2012.  
  2013.         PC = (src);;
  2014.         clkcount = 5;
  2015.           }
  2016.  
  2017.           break;
  2018.  
  2019.         case 109:
  2020.           {
  2021.         register p2 = load_abs_addr ();
  2022.         register unsigned src = LOAD (p2);
  2023.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2024.         PC += 3;
  2025.  
  2026.  
  2027.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2028.  
  2029.         /*
  2030.          * In decimal mode this is "correct" but not exact emulation. However,
  2031.          * the probability of different result when using undefined BCD codes is
  2032.          * less than 6%
  2033.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2034.          */
  2035.  
  2036.         if (IF_DECIMAL ())
  2037.           {
  2038.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2039.               temp += 6;
  2040.  
  2041.             SET_SIGN (temp);
  2042.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2043.  
  2044.             if (temp > 0x99)
  2045.               temp += 96;
  2046.  
  2047.             SET_CARRY (temp > 0x99);
  2048.           }
  2049.         else
  2050.           {
  2051.             SET_SIGN (temp);
  2052.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2053.             SET_CARRY (temp > 0xff);
  2054.           }
  2055.  
  2056.         AC = ((UBYTE) temp);;
  2057.         clkcount = 4;
  2058.           }
  2059.  
  2060.           break;
  2061.  
  2062.         case 110:
  2063.           {
  2064.         register p2 = load_abs_addr ();
  2065.         register unsigned src = LOAD (p2);
  2066.         PC += 3;
  2067.  
  2068.         if (IF_CARRY ())
  2069.           src |= 0x100;
  2070.         SET_CARRY (src & 0x01);
  2071.         src >>= 1;
  2072.  
  2073.         SET_SIGN (src);
  2074.         SET_ZERO (src);
  2075.  
  2076.         STORE (p2, (src));;
  2077.         clkcount = 6;
  2078.           }
  2079.  
  2080.           break;
  2081.  
  2082.         case 111:
  2083.           {
  2084.         register p2 = load_abs_addr ();
  2085.         register unsigned src = LOAD (p2);
  2086.         register unsigned int temp;
  2087.         PC += 3;
  2088.  
  2089.  
  2090.         /* src = ror(src); AC = adc(src);
  2091.          * the real operation discovered by msmakela
  2092.          * ADC only does the BCD fixup */
  2093.  
  2094.         temp = src >> 1;    /* ROR+ADC */
  2095.         if (IF_CARRY ())
  2096.           temp |= 0x80;
  2097.  
  2098.         SET_SIGN (temp);
  2099.         SET_ZERO (temp);    /* Set flags like ROR does */
  2100.  
  2101.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2102.  
  2103.         if (IF_DECIMAL ())
  2104.           {
  2105.             if ((src & 0x0f) > 4)    /* half of the normal */
  2106.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2107.             if (src > 0x4f)
  2108.               temp += 96;
  2109.  
  2110.             SET_CARRY (src > 0x4f);
  2111.           }
  2112.         else
  2113.           {
  2114.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2115.           }
  2116.  
  2117.  
  2118.         STORE (p2, ((UBYTE) temp));;
  2119.         clkcount = 6;
  2120.           }
  2121.  
  2122.           break;
  2123.  
  2124.         case 112:
  2125. /*   BVS,    RELATIVE */
  2126.           {
  2127.         register p1 = LOAD (PC + 1);
  2128.         register unsigned src = p1;
  2129.         register UBYTE hb;
  2130.         PC += 2;
  2131.         /* Branch if overflow flag is set. */
  2132.         if (IF_OVERFLOW ())
  2133.           {
  2134.             hb = UPPER (PC);
  2135.             PC = REL_ADDR (PC, src);
  2136.             if (brtest (hb))
  2137.               /* Same page */
  2138.               clkcount = 3;
  2139.             else
  2140.               /* Different page */
  2141.               clkcount = 4;
  2142.           }
  2143.         else
  2144.           clkcount = 2;
  2145.           }
  2146.  
  2147.           break;
  2148.  
  2149.         case 113:
  2150.           {
  2151.         register p1 = LOAD (PC + 1);
  2152.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  2153.         register unsigned src = LOAD (p2 + YR);
  2154.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2155.         PC += 2;
  2156.  
  2157.         if (pagetest (p2, YR))
  2158.           /* Over page */
  2159.           clkcount = 6;
  2160.         else
  2161.           /* Same page */
  2162.           clkcount = 5;
  2163.  
  2164.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2165.  
  2166.         /*
  2167.          * In decimal mode this is "correct" but not exact emulation. However,
  2168.          * the probability of different result when using undefined BCD codes is
  2169.          * less than 6%
  2170.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2171.          */
  2172.  
  2173.         if (IF_DECIMAL ())
  2174.           {
  2175.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2176.               temp += 6;
  2177.  
  2178.             SET_SIGN (temp);
  2179.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2180.  
  2181.             if (temp > 0x99)
  2182.               temp += 96;
  2183.  
  2184.             SET_CARRY (temp > 0x99);
  2185.           }
  2186.         else
  2187.           {
  2188.             SET_SIGN (temp);
  2189.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2190.             SET_CARRY (temp > 0xff);
  2191.           }
  2192.  
  2193.         AC = ((UBYTE) temp);
  2194.           }
  2195.  
  2196.           break;
  2197.  
  2198.         case 115:
  2199.           {
  2200.         register p1 = LOAD (PC + 1);
  2201.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  2202.         register unsigned int temp;
  2203.         PC += 2;
  2204.  
  2205.  
  2206.         /* src = ror(src); AC = adc(src);
  2207.          * the real operation discovered by msmakela
  2208.          * ADC only does the BCD fixup */
  2209.  
  2210.         temp = src >> 1;    /* ROR+ADC */
  2211.         if (IF_CARRY ())
  2212.           temp |= 0x80;
  2213.  
  2214.         SET_SIGN (temp);
  2215.         SET_ZERO (temp);    /* Set flags like ROR does */
  2216.  
  2217.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2218.  
  2219.         if (IF_DECIMAL ())
  2220.           {
  2221.             if ((src & 0x0f) > 4)    /* half of the normal */
  2222.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2223.             if (src > 0x4f)
  2224.               temp += 96;
  2225.  
  2226.             SET_CARRY (src > 0x4f);
  2227.           }
  2228.         else
  2229.           {
  2230.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2231.           }
  2232.  
  2233.  
  2234.         STORE (LOAD_ZERO_ADDR (p1) + YR, ((UBYTE) temp));;
  2235.         clkcount = 8;
  2236.           }
  2237.  
  2238.           break;
  2239.  
  2240.         case 116:
  2241.           {
  2242.         PC += 2;
  2243.  
  2244.         clkcount = 4;
  2245.           }
  2246.  
  2247.           break;
  2248.  
  2249.         case 117:
  2250.           {
  2251.         register p1 = LOAD (PC + 1);
  2252.         register unsigned src = LOAD_ZERO (p1 + XR);
  2253.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2254.         PC += 2;
  2255.  
  2256.  
  2257.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2258.  
  2259.         /*
  2260.          * In decimal mode this is "correct" but not exact emulation. However,
  2261.          * the probability of different result when using undefined BCD codes is
  2262.          * less than 6%
  2263.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2264.          */
  2265.  
  2266.         if (IF_DECIMAL ())
  2267.           {
  2268.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2269.               temp += 6;
  2270.  
  2271.             SET_SIGN (temp);
  2272.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2273.  
  2274.             if (temp > 0x99)
  2275.               temp += 96;
  2276.  
  2277.             SET_CARRY (temp > 0x99);
  2278.           }
  2279.         else
  2280.           {
  2281.             SET_SIGN (temp);
  2282.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2283.             SET_CARRY (temp > 0xff);
  2284.           }
  2285.  
  2286.         AC = ((UBYTE) temp);;
  2287.         clkcount = 4;
  2288.           }
  2289.  
  2290.           break;
  2291.  
  2292.         case 118:
  2293.           {
  2294.         register p1 = LOAD (PC + 1);
  2295.         register unsigned src = LOAD_ZERO (p1 + XR);
  2296.         PC += 2;
  2297.  
  2298.         if (IF_CARRY ())
  2299.           src |= 0x100;
  2300.         SET_CARRY (src & 0x01);
  2301.         src >>= 1;
  2302.  
  2303.         SET_SIGN (src);
  2304.         SET_ZERO (src);
  2305.  
  2306.         STORE_ZERO (p1 + XR, (src));;
  2307.         clkcount = 6;
  2308.           }
  2309.  
  2310.           break;
  2311.  
  2312.         case 119:
  2313.           {
  2314.         register p1 = LOAD (PC + 1);
  2315.         register unsigned src = LOAD_ZERO (p1 + XR);
  2316.         register unsigned int temp;
  2317.         PC += 2;
  2318.  
  2319.  
  2320.         /* src = ror(src); AC = adc(src);
  2321.          * the real operation discovered by msmakela
  2322.          * ADC only does the BCD fixup */
  2323.  
  2324.         temp = src >> 1;    /* ROR+ADC */
  2325.         if (IF_CARRY ())
  2326.           temp |= 0x80;
  2327.  
  2328.         SET_SIGN (temp);
  2329.         SET_ZERO (temp);    /* Set flags like ROR does */
  2330.  
  2331.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2332.  
  2333.         if (IF_DECIMAL ())
  2334.           {
  2335.             if ((src & 0x0f) > 4)    /* half of the normal */
  2336.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2337.             if (src > 0x4f)
  2338.               temp += 96;
  2339.  
  2340.             SET_CARRY (src > 0x4f);
  2341.           }
  2342.         else
  2343.           {
  2344.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2345.           }
  2346.  
  2347.  
  2348.         STORE_ZERO (p1 + XR, ((UBYTE) temp));;
  2349.         clkcount = 6;
  2350.           }
  2351.  
  2352.           break;
  2353.  
  2354.         case 120:
  2355.           {
  2356.         PC++;
  2357.  
  2358.  
  2359.         SET_INTERRUPT ((1));;
  2360.         clkcount = 2;
  2361.           }
  2362.  
  2363.           break;
  2364.  
  2365.         case 121:
  2366. /*   ADC,    ABSOLUTE_Y */
  2367.           {
  2368.         register p2 = load_abs_addr ();
  2369.         register unsigned src = LOAD (p2 + YR);
  2370.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2371.         PC += 3;
  2372.  
  2373.         if (pagetest (p2, YR))
  2374.           /* Over page */
  2375.           clkcount = 5;
  2376.         else
  2377.           /* Same page */
  2378.           clkcount = 4;
  2379.  
  2380.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2381.  
  2382.         /*
  2383.          * In decimal mode this is "correct" but not exact emulation. However,
  2384.          * the probability of different result when using undefined BCD codes is
  2385.          * less than 6%
  2386.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2387.          */
  2388.  
  2389.         if (IF_DECIMAL ())
  2390.           {
  2391.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2392.               temp += 6;
  2393.  
  2394.             SET_SIGN (temp);
  2395.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2396.  
  2397.             if (temp > 0x99)
  2398.               temp += 96;
  2399.  
  2400.             SET_CARRY (temp > 0x99);
  2401.           }
  2402.         else
  2403.           {
  2404.             SET_SIGN (temp);
  2405.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2406.             SET_CARRY (temp > 0xff);
  2407.           }
  2408.  
  2409.         AC = ((UBYTE) temp);
  2410.           }
  2411.  
  2412.           break;
  2413.  
  2414.         case 122:
  2415.           {
  2416.         PC++;
  2417.  
  2418.         clkcount = 2;
  2419.           }
  2420.  
  2421.           break;
  2422.  
  2423.         case 123:
  2424.           {
  2425.         register p2 = load_abs_addr ();
  2426.         register unsigned src = LOAD (p2 + YR);
  2427.         register unsigned int temp;
  2428.         PC += 3;
  2429.  
  2430.  
  2431.         /* src = ror(src); AC = adc(src);
  2432.          * the real operation discovered by msmakela
  2433.          * ADC only does the BCD fixup */
  2434.  
  2435.         temp = src >> 1;    /* ROR+ADC */
  2436.         if (IF_CARRY ())
  2437.           temp |= 0x80;
  2438.  
  2439.         SET_SIGN (temp);
  2440.         SET_ZERO (temp);    /* Set flags like ROR does */
  2441.  
  2442.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2443.  
  2444.         if (IF_DECIMAL ())
  2445.           {
  2446.             if ((src & 0x0f) > 4)    /* half of the normal */
  2447.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2448.             if (src > 0x4f)
  2449.               temp += 96;
  2450.  
  2451.             SET_CARRY (src > 0x4f);
  2452.           }
  2453.         else
  2454.           {
  2455.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2456.           }
  2457.  
  2458.  
  2459.         STORE (p2 + YR, ((UBYTE) temp));;
  2460.         clkcount = 7;
  2461.           }
  2462.  
  2463.           break;
  2464.  
  2465.         case 124:
  2466.           {
  2467.         PC += 3;
  2468.  
  2469.         clkcount = 4;
  2470.           }
  2471.  
  2472.           break;
  2473.  
  2474.         case 125:
  2475. /*  ADC,    ABSOLUTE_X */
  2476.           {
  2477.         register p2 = load_abs_addr ();
  2478.         register unsigned src = LOAD (p2 + XR);
  2479.         register unsigned int temp = src + AC + (IF_CARRY ()? 1 : 0);
  2480.         PC += 3;
  2481.  
  2482.         if (pagetest (p2, XR))
  2483.           /* Over page */
  2484.           clkcount = 5;
  2485.         else
  2486.           /* Same page */
  2487.           clkcount = 4;
  2488.  
  2489.         SET_ZERO (temp & 0xff);        /* This is not valid in decimal mode */
  2490.  
  2491.         /*
  2492.          * In decimal mode this is "correct" but not exact emulation. However,
  2493.          * the probability of different result when using undefined BCD codes is
  2494.          * less than 6%
  2495.          * Sign and Overflow are set between BCD fixup of the two digits  -MSM
  2496.          */
  2497.  
  2498.         if (IF_DECIMAL ())
  2499.           {
  2500.             if (((AC & 0xf) + (src & 0xf) + (IF_CARRY ()? 1 : 0)) > 9)
  2501.               temp += 6;
  2502.  
  2503.             SET_SIGN (temp);
  2504.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2505.  
  2506.             if (temp > 0x99)
  2507.               temp += 96;
  2508.  
  2509.             SET_CARRY (temp > 0x99);
  2510.           }
  2511.         else
  2512.           {
  2513.             SET_SIGN (temp);
  2514.             SET_OVERFLOW (!((AC ^ src) & 0x80) && ((AC ^ temp) & 0x80));
  2515.             SET_CARRY (temp > 0xff);
  2516.           }
  2517.  
  2518.         AC = ((UBYTE) temp);
  2519.           }
  2520.  
  2521.           break;
  2522.  
  2523.         case 126:
  2524.           {
  2525.         register p2 = load_abs_addr ();
  2526.         register unsigned src = LOAD (p2 + XR);
  2527.         PC += 3;
  2528.  
  2529.         if (IF_CARRY ())
  2530.           src |= 0x100;
  2531.         SET_CARRY (src & 0x01);
  2532.         src >>= 1;
  2533.  
  2534.         SET_SIGN (src);
  2535.         SET_ZERO (src);
  2536.  
  2537.         STORE (p2 + XR, (src));;
  2538.         clkcount = 7;
  2539.           }
  2540.  
  2541.           break;
  2542.  
  2543.         case 127:
  2544.           {
  2545.         register p2 = load_abs_addr ();
  2546.         register unsigned src = LOAD (p2 + XR);
  2547.         register unsigned int temp;
  2548.         PC += 3;
  2549.  
  2550.  
  2551.         /* src = ror(src); AC = adc(src);
  2552.          * the real operation discovered by msmakela
  2553.          * ADC only does the BCD fixup */
  2554.  
  2555.         temp = src >> 1;    /* ROR+ADC */
  2556.         if (IF_CARRY ())
  2557.           temp |= 0x80;
  2558.  
  2559.         SET_SIGN (temp);
  2560.         SET_ZERO (temp);    /* Set flags like ROR does */
  2561.  
  2562.         SET_OVERFLOW ((temp ^ src) & 0x40);    /* ROR causes this ? */
  2563.  
  2564.         if (IF_DECIMAL ())
  2565.           {
  2566.             if ((src & 0x0f) > 4)    /* half of the normal */
  2567.               temp = (temp & 0xf0) | ((temp + 6) & 0xf);
  2568.             if (src > 0x4f)
  2569.               temp += 96;
  2570.  
  2571.             SET_CARRY (src > 0x4f);
  2572.           }
  2573.         else
  2574.           {
  2575.             SET_CARRY (src & 0x80);    /* 8502 behaviour */
  2576.           }
  2577.  
  2578.  
  2579.         STORE (p2 + XR, ((UBYTE) temp));;
  2580.         clkcount = 7;
  2581.           }
  2582.  
  2583.           break;
  2584.  
  2585.         case 128:
  2586.           {
  2587.         PC += 2;
  2588.  
  2589.         clkcount = 2;
  2590.           }
  2591.  
  2592.           break;
  2593.  
  2594.         case 129:
  2595.           {
  2596.         register p1 = LOAD (PC + 1);
  2597.         register unsigned src = AC;
  2598.         PC += 2;
  2599.  
  2600.  
  2601.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  2602.         clkcount = 6;
  2603.           }
  2604.  
  2605.           break;
  2606.  
  2607.         case 130:
  2608.           {
  2609.         PC += 2;
  2610.  
  2611.         clkcount = 2;
  2612.           }
  2613.  
  2614.           break;
  2615.  
  2616.         case 131:
  2617.           {
  2618.         register p1 = LOAD (PC + 1);
  2619.         register unsigned src = (AC & XR);
  2620.         PC += 2;
  2621.  
  2622.  
  2623.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  2624.         clkcount = 6;
  2625.           }
  2626.  
  2627.           break;
  2628.  
  2629.         case 132:
  2630. /*  STY,    ZERO_PAGE */
  2631.           {
  2632.         register p1 = LOAD (PC + 1);
  2633.         register unsigned src = YR;
  2634.  
  2635.         clkcount = 3;
  2636.         PC += 2;
  2637.  
  2638.         beamadj = BEAMNINE;
  2639.         STORE_ZERO (p1, (src));
  2640.           }
  2641.  
  2642.           break;
  2643.  
  2644.         case 133:
  2645. /*   STA,    ZERO_PAGE */
  2646.           {
  2647.         register p1 = LOAD (PC + 1);
  2648.         register unsigned src = AC;
  2649.  
  2650.         clkcount = 3;
  2651.         PC += 2;
  2652.  
  2653.         beamadj = BEAMNINE;
  2654.         STORE_ZERO (p1, (src));
  2655.           }
  2656.  
  2657.           break;
  2658.  
  2659.         case 134:
  2660. /*  STX,    ZERO_PAGE */
  2661.           {
  2662.         register p1 = LOAD (PC + 1);
  2663.         register unsigned src = XR;
  2664.  
  2665.         clkcount = 3;
  2666.         PC += 2;
  2667.  
  2668.         beamadj = BEAMNINE;
  2669.         STORE_ZERO (p1, (src));
  2670.           }
  2671.  
  2672.           break;
  2673.  
  2674.         case 135:
  2675.           {
  2676.         register p1 = LOAD (PC + 1);
  2677.         register unsigned src = (AC & XR);
  2678.         PC += 2;
  2679.  
  2680.  
  2681.         STORE_ZERO (p1, (src));;
  2682.         clkcount = 3;
  2683.           }
  2684.  
  2685.           break;
  2686.  
  2687.         case 136:
  2688.           {
  2689.         register unsigned src = YR;
  2690.         PC++;
  2691.  
  2692.         src = (src - 1) & 0xff;
  2693.         SET_SIGN (src);
  2694.         SET_ZERO (src);
  2695.  
  2696.         YR = (src);;
  2697.         clkcount = 2;
  2698.           }
  2699.  
  2700.           break;
  2701.  
  2702.         case 137:
  2703.           {
  2704.         PC += 2;
  2705.  
  2706.         clkcount = 2;
  2707.           }
  2708.  
  2709.           break;
  2710.  
  2711.         case 138:
  2712.           {
  2713.         register unsigned src = XR;
  2714.         PC++;
  2715.  
  2716.         SET_SIGN (src);
  2717.         SET_ZERO (src);
  2718.  
  2719.         AC = (src);;
  2720.         clkcount = 2;
  2721.           }
  2722.  
  2723.           break;
  2724.  
  2725.         case 139:
  2726.           {
  2727.         register p1 = LOAD (PC + 1);
  2728.         register unsigned src = ((AC | 0xee) & XR & p1);
  2729.         PC += 2;
  2730.  
  2731.         SET_SIGN (src);
  2732.         SET_ZERO (src);
  2733.  
  2734.         AC = (src);;
  2735.         clkcount = 2;
  2736.           }
  2737.  
  2738.           break;
  2739.  
  2740.         case 140:
  2741. /*  STY,    ABSOLUTE */
  2742.           {
  2743.         register p2 = load_abs_addr ();
  2744.         register unsigned src = YR;
  2745.         PC += 3;
  2746.  
  2747.         beamadj = BEAMTWELVE;
  2748.         STORE (p2, (src));;
  2749.         clkcount = 4;
  2750.           }
  2751.  
  2752.           break;
  2753.  
  2754.         case 141:
  2755. /*  STA,    ABSOLUTE */
  2756.           {
  2757.         register p2 = load_abs_addr ();
  2758.         register unsigned src = AC;
  2759.         PC += 3;
  2760.  
  2761.         beamadj = BEAMTWELVE;
  2762.         STORE (p2, (src));;
  2763.         clkcount = 4;
  2764.           }
  2765.  
  2766.           break;
  2767.  
  2768.         case 142:
  2769. /*  STA,    ABSOLUTE */
  2770.           {
  2771.         register p2 = load_abs_addr ();
  2772.         register unsigned src = XR;
  2773.         PC += 3;
  2774.  
  2775.         beamadj = BEAMTWELVE;
  2776.         STORE (p2, (src));;
  2777.         clkcount = 4;
  2778.           }
  2779.  
  2780.           break;
  2781.  
  2782.         case 143:
  2783. /* STX,    ABSOLUTE */
  2784.           {
  2785.         register p2 = load_abs_addr ();
  2786.         register unsigned src = (AC & XR);
  2787.         PC += 3;
  2788.  
  2789.         beamadj = BEAMTWELVE;
  2790.         STORE (p2, (src));;
  2791.         clkcount = 4;
  2792.           }
  2793.  
  2794.           break;
  2795.  
  2796.         case 144:
  2797. /*  BCC,    RELATIVE */
  2798.           {
  2799.         register p1 = LOAD (PC + 1);
  2800.         register hb;
  2801.         register unsigned src = p1;
  2802.         PC += 2;
  2803.         /* Branch if carry flag is clear. */
  2804.         if (!IF_CARRY ())
  2805.           {
  2806.             hb = UPPER (PC);
  2807.             PC = REL_ADDR (PC, src);
  2808.             if (brtest (hb))
  2809.               /* Same page */
  2810.               clkcount = 3;
  2811.             else
  2812.               /* Different page */
  2813.               clkcount = 4;
  2814.           }
  2815.         else
  2816.           clkcount = 2;
  2817.           }
  2818.  
  2819.           break;
  2820.  
  2821.         case 145:
  2822.           {
  2823.         register p1 = LOAD (PC + 1);
  2824.         register unsigned src = AC;
  2825.         PC += 2;
  2826.  
  2827.  
  2828.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  2829.         clkcount = 6;
  2830.           }
  2831.  
  2832.           break;
  2833.  
  2834.         case 147:
  2835.           {
  2836.         register p1 = LOAD (PC + 1);
  2837.         register unsigned src = (AC & XR);
  2838.         PC += 2;
  2839.  
  2840.  
  2841.         u_stoshr (src, LOAD_ZERO_ADDR (p1), YR);;
  2842.         clkcount = 6;
  2843.           }
  2844.  
  2845.           break;
  2846.  
  2847.         case 148:
  2848.           {
  2849.         register p1 = LOAD (PC + 1);
  2850.         register unsigned src = YR;
  2851.         clkcount = 4;
  2852.         PC += 2;
  2853.  
  2854.         beamadj = BEAMTWELVE;
  2855.         STORE_ZERO (p1 + XR, (src));
  2856.           }
  2857.  
  2858.           break;
  2859.  
  2860.         case 149:
  2861. /*  STA,    ZERO_PAGE_X */
  2862.           {
  2863.         register p1 = LOAD (PC + 1);
  2864.         register unsigned src = AC;
  2865.         clkcount = 4;
  2866.         PC += 2;
  2867.  
  2868.         beamadj = BEAMTWELVE;
  2869.         STORE_ZERO (p1 + XR, (src));
  2870.           }
  2871.  
  2872.           break;
  2873.  
  2874.         case 150:
  2875. /* STX,    ZERO_PAGE_Y */
  2876.           {
  2877.         register p1 = LOAD (PC + 1);
  2878.         register unsigned src = XR;
  2879.         clkcount = 4;
  2880.         PC += 2;
  2881.  
  2882.         beamadj = BEAMTWELVE;
  2883.         STORE_ZERO (p1 + YR, (src));
  2884.           }
  2885.  
  2886.           break;
  2887.  
  2888.         case 151:
  2889.           {
  2890.         register p1 = LOAD (PC + 1);
  2891.         register unsigned src = (AC & XR);
  2892.         PC += 2;
  2893.  
  2894.  
  2895.         STORE_ZERO (p1 + YR, (src));;
  2896.         clkcount = 4;
  2897.           }
  2898.  
  2899.           break;
  2900.  
  2901.         case 152:
  2902.           {
  2903.         register unsigned src = YR;
  2904.         PC++;
  2905.  
  2906.         SET_SIGN (src);
  2907.         SET_ZERO (src);
  2908.  
  2909.         AC = (src);;
  2910.         clkcount = 2;
  2911.           }
  2912.  
  2913.           break;
  2914.  
  2915.         case 153:
  2916.           {
  2917.         register p2 = load_abs_addr ();
  2918.         register unsigned src = AC;
  2919.         PC += 3;
  2920.  
  2921.  
  2922.         STORE (p2 + YR, (src));;
  2923.         clkcount = 5;
  2924.           }
  2925.  
  2926.           break;
  2927.  
  2928.         case 154:
  2929.           {
  2930.         register unsigned src = XR;
  2931.         PC++;
  2932.  
  2933.  
  2934.         SP = (src);;
  2935.         clkcount = 2;
  2936.           }
  2937.  
  2938.           break;
  2939.  
  2940.         case 155:
  2941.           {
  2942.         register unsigned src = (AC & XR);
  2943.         PC += 3;
  2944.  
  2945.  
  2946.         SP = src; /* SHS */ ;
  2947.         clkcount = 5;
  2948.           }
  2949.  
  2950.           break;
  2951.  
  2952.         case 156:
  2953.           {
  2954.         register p2 = load_abs_addr ();
  2955.         register unsigned src = YR;
  2956.         PC += 3;
  2957.  
  2958.  
  2959.         u_stoshr (src, p2, XR);;
  2960.         clkcount = 5;
  2961.           }
  2962.  
  2963.           break;
  2964.  
  2965.         case 157:
  2966.           {
  2967.         register p2 = load_abs_addr ();
  2968.         register unsigned src = AC;
  2969.         PC += 3;
  2970.  
  2971.  
  2972.         STORE (p2 + XR, (src));;
  2973.         clkcount = 5;
  2974.           }
  2975.  
  2976.           break;
  2977.  
  2978.         case 158:
  2979.           {
  2980.         register p2 = load_abs_addr ();
  2981.         register unsigned src = XR;
  2982.         PC += 3;
  2983.  
  2984.  
  2985.         u_stoshr (src, p2, YR);;
  2986.         clkcount = 5;
  2987.           }
  2988.  
  2989.           break;
  2990.  
  2991.         case 159:
  2992.           {
  2993.         register p2 = load_abs_addr ();
  2994.         register unsigned src = (AC & XR);
  2995.         PC += 3;
  2996.  
  2997.  
  2998.         u_stoshr (src, p2, YR);;
  2999.         clkcount = 5;
  3000.           }
  3001.  
  3002.           break;
  3003.  
  3004.         case 160:
  3005.           {
  3006.         register p1 = LOAD (PC + 1);
  3007.         register unsigned src = p1;
  3008.         PC += 2;
  3009.  
  3010.         SET_SIGN (src);
  3011.         SET_ZERO (src);
  3012.  
  3013.         YR = (src);;
  3014.         clkcount = 2;
  3015.           }
  3016.  
  3017.           break;
  3018.  
  3019.         case 161:
  3020.           {
  3021.         register p1 = LOAD (PC + 1);
  3022.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  3023.         PC += 2;
  3024.  
  3025.         SET_SIGN (src);
  3026.         SET_ZERO (src);
  3027.  
  3028.         AC = (src);;
  3029.         clkcount = 6;
  3030.           }
  3031.  
  3032.           break;
  3033.  
  3034.         case 162:
  3035.           {
  3036.         register p1 = LOAD (PC + 1);
  3037.         register unsigned src = p1;
  3038.         PC += 2;
  3039.  
  3040.         SET_SIGN (src);
  3041.         SET_ZERO (src);
  3042.  
  3043.         XR = (src);;
  3044.         clkcount = 2;
  3045.           }
  3046.  
  3047.           break;
  3048.  
  3049.         case 163:
  3050.           {
  3051.         register p1 = LOAD (PC + 1);
  3052.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  3053.         PC += 2;
  3054.  
  3055.         SET_SIGN (src);
  3056.         SET_ZERO (src);
  3057.  
  3058.         AC = XR = (src);;
  3059.         clkcount = 6;
  3060.           }
  3061.  
  3062.           break;
  3063.  
  3064.         case 164:
  3065.           {
  3066.         register p1 = LOAD (PC + 1);
  3067.         register unsigned src = LOAD_ZERO (p1);
  3068.         PC += 2;
  3069.  
  3070.         SET_SIGN (src);
  3071.         SET_ZERO (src);
  3072.  
  3073.         YR = (src);;
  3074.         clkcount = 3;
  3075.           }
  3076.  
  3077.           break;
  3078.  
  3079.         case 165:
  3080.           {
  3081.         register p1 = LOAD (PC + 1);
  3082.         register unsigned src = LOAD_ZERO (p1);
  3083.         PC += 2;
  3084.  
  3085.         SET_SIGN (src);
  3086.         SET_ZERO (src);
  3087.  
  3088.         AC = (src);;
  3089.         clkcount = 3;
  3090.           }
  3091.  
  3092.           break;
  3093.  
  3094.         case 166:
  3095. /*      LDX,   ZERO_PAGE */
  3096.           {
  3097.         register p1 = LOADEXEC (PC + 1);
  3098.         register unsigned src = LOAD_ZERO (p1);
  3099.  
  3100.         clkcount = 3;
  3101.         PC += 2;
  3102.  
  3103.         SET_SIGN (src);
  3104.         SET_ZERO (src);
  3105.  
  3106.         XR = (src);
  3107.           }
  3108.  
  3109.           break;
  3110.  
  3111.         case 167:
  3112.           {
  3113.         register p1 = LOAD (PC + 1);
  3114.         register unsigned src = LOAD_ZERO (p1);
  3115.         PC += 2;
  3116.  
  3117.         SET_SIGN (src);
  3118.         SET_ZERO (src);
  3119.  
  3120.         AC = XR = (src);;
  3121.         clkcount = 3;
  3122.           }
  3123.  
  3124.           break;
  3125.  
  3126.         case 168:
  3127.           {
  3128.         register unsigned src = AC;
  3129.         PC++;
  3130.  
  3131.         SET_SIGN (src);
  3132.         SET_ZERO (src);
  3133.  
  3134.         YR = (src);;
  3135.         clkcount = 2;
  3136.           }
  3137.  
  3138.           break;
  3139.  
  3140.         case 169:
  3141.           {
  3142.         register p1 = LOAD (PC + 1);
  3143.         register unsigned src = p1;
  3144.         PC += 2;
  3145.  
  3146.         SET_SIGN (src);
  3147.         SET_ZERO (src);
  3148.  
  3149.         AC = (src);;
  3150.         clkcount = 2;
  3151.           }
  3152.  
  3153.           break;
  3154.  
  3155.         case 170:
  3156.           {
  3157.         register unsigned src = AC;
  3158.         PC++;
  3159.  
  3160.         SET_SIGN (src);
  3161.         SET_ZERO (src);
  3162.  
  3163.         XR = (src);;
  3164.         clkcount = 2;
  3165.           }
  3166.  
  3167.           break;
  3168.  
  3169.         case 171:
  3170.           {
  3171.         register p1 = LOAD (PC + 1);
  3172.         register unsigned src = (AC & p1);
  3173.         PC += 2;
  3174.  
  3175.         SET_SIGN (src);
  3176.         SET_ZERO (src);
  3177.  
  3178.         AC = XR = (src);;
  3179.         clkcount = 2;
  3180.           }
  3181.  
  3182.           break;
  3183.  
  3184.         case 172:
  3185.           {
  3186.         register p2 = load_abs_addr ();
  3187.         register unsigned src = LOAD (p2);
  3188.         PC += 3;
  3189.  
  3190.         SET_SIGN (src);
  3191.         SET_ZERO (src);
  3192.  
  3193.         YR = (src);;
  3194.         clkcount = 4;
  3195.           }
  3196.  
  3197.           break;
  3198.  
  3199.         case 173:        /* LDA absolute */
  3200.           {
  3201.         register p2 = load_abs_addr ();
  3202.         register unsigned src;
  3203.         clkcount = 4;
  3204.         src = LOAD (p2);
  3205.         PC += 3;
  3206.  
  3207.         SET_SIGN (src);
  3208.         SET_ZERO (src);
  3209.  
  3210.         AC = (src);
  3211.           }
  3212.  
  3213.           break;
  3214.  
  3215.         case 174:
  3216.           {
  3217.         register p2 = load_abs_addr ();
  3218.         register unsigned src = LOAD (p2);
  3219.         PC += 3;
  3220.  
  3221.         SET_SIGN (src);
  3222.         SET_ZERO (src);
  3223.  
  3224.         XR = (src);;
  3225.         clkcount = 4;
  3226.           }
  3227.  
  3228.           break;
  3229.  
  3230.         case 175:
  3231.           {
  3232.         register p2 = load_abs_addr ();
  3233.         register unsigned src = LOAD (p2);
  3234.         PC += 3;
  3235.  
  3236.         SET_SIGN (src);
  3237.         SET_ZERO (src);
  3238.  
  3239.         AC = XR = (src);;
  3240.         clkcount = 4;
  3241.           }
  3242.  
  3243.           break;
  3244.  
  3245.         case 176:
  3246. /*   BCS,    RELATIVE */
  3247.           {
  3248.         register p1 = LOAD (PC + 1);
  3249.         register unsigned src = p1;
  3250.         register UBYTE hb;
  3251.         PC += 2;
  3252.         /* Branch if carry flag is set. */
  3253.         if (IF_CARRY ())
  3254.           {
  3255.             hb = UPPER (PC);
  3256.             PC = REL_ADDR (PC, src);
  3257.             if (brtest (hb))
  3258.               /* Same page */
  3259.               clkcount = 3;
  3260.             else
  3261.               /* Different page */
  3262.               clkcount = 4;
  3263.           }
  3264.         else
  3265.           clkcount = 2;
  3266.           }
  3267.  
  3268.           break;
  3269.  
  3270.         case 177:
  3271. /*   LDA,    INDIRECT_Y */
  3272.           {
  3273.         register p1 = LOAD (PC + 1);
  3274.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  3275.         register unsigned src = LOAD (p2 + YR);
  3276.         PC += 2;
  3277.  
  3278.         if (pagetest (p2, YR))
  3279.           /* Over page */
  3280.           clkcount = 6;
  3281.         else
  3282.           /* Same page */
  3283.           clkcount = 5;
  3284.  
  3285.         SET_SIGN (src);
  3286.         SET_ZERO (src);
  3287.  
  3288.         AC = (src);
  3289.           }
  3290.  
  3291.           break;
  3292.  
  3293.         case 179:
  3294. /*   LAX,    INDIRECT_Y */
  3295.           {
  3296.         register p1 = LOAD (PC + 1);
  3297.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  3298.         register unsigned src = LOAD (p2 + YR);
  3299.         PC += 2;
  3300.         if (pagetest (p2, YR))
  3301.           /* Over page */
  3302.           clkcount = 6;
  3303.         else
  3304.           /* Same page */
  3305.           clkcount = 5;
  3306.  
  3307.         SET_SIGN (src);
  3308.         SET_ZERO (src);
  3309.  
  3310.         AC = XR = (src);
  3311.           }
  3312.  
  3313.           break;
  3314.  
  3315.         case 180:
  3316.           {
  3317.         register p1 = LOAD (PC + 1);
  3318.         register unsigned src = LOAD_ZERO (p1 + XR);
  3319.         PC += 2;
  3320.  
  3321.         SET_SIGN (src);
  3322.         SET_ZERO (src);
  3323.  
  3324.         YR = (src);;
  3325.         clkcount = 4;
  3326.           }
  3327.  
  3328.           break;
  3329.  
  3330.         case 181:
  3331.           {
  3332.         register p1 = LOAD (PC + 1);
  3333.         register unsigned src = LOAD_ZERO (p1 + XR);
  3334.         PC += 2;
  3335.  
  3336.         SET_SIGN (src);
  3337.         SET_ZERO (src);
  3338.  
  3339.         AC = (src);;
  3340.         clkcount = 4;
  3341.           }
  3342.  
  3343.           break;
  3344.  
  3345.         case 182:
  3346.           {
  3347.         register p1 = LOAD (PC + 1);
  3348.         register unsigned src = LOAD_ZERO (p1 + YR);
  3349.         PC += 2;
  3350.  
  3351.         SET_SIGN (src);
  3352.         SET_ZERO (src);
  3353.  
  3354.         XR = (src);;
  3355.         clkcount = 4;
  3356.           }
  3357.  
  3358.           break;
  3359.  
  3360.         case 183:
  3361.           {
  3362.         register p1 = LOAD (PC + 1);
  3363.         register unsigned src = LOAD_ZERO (p1 + YR);
  3364.         PC += 2;
  3365.  
  3366.         SET_SIGN (src);
  3367.         SET_ZERO (src);
  3368.  
  3369.         AC = XR = (src);;
  3370.         clkcount = 4;
  3371.           }
  3372.  
  3373.           break;
  3374.  
  3375.         case 184:
  3376.           {
  3377.         PC++;
  3378.  
  3379.  
  3380.         SET_OVERFLOW ((0));;
  3381.         clkcount = 2;
  3382.           }
  3383.  
  3384.           break;
  3385.  
  3386.         case 185:
  3387.           {
  3388.         register p2 = load_abs_addr ();
  3389.         register unsigned src = LOAD (p2 + YR);
  3390.         PC += 3;
  3391.         if (pagetest (p2, YR))
  3392.           /* Over page */
  3393.           clkcount = 5;
  3394.         else
  3395.           /* Same page */
  3396.           clkcount = 4;
  3397.  
  3398.         SET_SIGN (src);
  3399.         SET_ZERO (src);
  3400.  
  3401.         AC = (src);
  3402.           }
  3403.  
  3404.           break;
  3405.  
  3406.         case 186:
  3407.           {
  3408.         register unsigned src = SP;
  3409.         PC++;
  3410.  
  3411.         SET_SIGN (src);
  3412.         SET_ZERO (src);
  3413.  
  3414.         XR = (src);;
  3415.         clkcount = 2;
  3416.           }
  3417.  
  3418.           break;
  3419.  
  3420.         case 187:
  3421.           {
  3422.         register p2 = load_abs_addr ();
  3423.         register unsigned src = (SP & LOAD (p2 + YR));
  3424.         PC += 3;
  3425.         if (pagetest (p2, YR))
  3426.           /* Over page */
  3427.           clkcount = 5;
  3428.         else
  3429.           /* Same page */
  3430.           clkcount = 4;
  3431.  
  3432.         SET_SIGN (src);
  3433.         SET_ZERO (src);
  3434.  
  3435.         AC = XR = SP = (src);
  3436.           }
  3437.  
  3438.           break;
  3439.  
  3440.         case 188:
  3441. /*   LDY,    ABSOLUTE_X */
  3442.           {
  3443.         register p2 = load_abs_addr ();
  3444.         register unsigned src = LOAD (p2 + XR);
  3445.         PC += 3;
  3446.         if (pagetest (p2, XR))
  3447.           /* Over page */
  3448.           clkcount = 5;
  3449.         else
  3450.           /* Same page */
  3451.           clkcount = 4;
  3452.  
  3453.  
  3454.         SET_SIGN (src);
  3455.         SET_ZERO (src);
  3456.  
  3457.         YR = (src);
  3458.           }
  3459.  
  3460.           break;
  3461.  
  3462.         case 189:
  3463. /*  LDA,    ABSOLUTE_X */
  3464.           {
  3465.         register p2 = load_abs_addr ();
  3466.         register unsigned src = LOAD (p2 + XR);
  3467.         PC += 3;
  3468.  
  3469.         if (pagetest (p2, XR))
  3470.           /* Over page */
  3471.           clkcount = 5;
  3472.         else
  3473.           /* Same page */
  3474.           clkcount = 4;
  3475.  
  3476.         SET_SIGN (src);
  3477.         SET_ZERO (src);
  3478.  
  3479.         AC = (src);
  3480.           }
  3481.  
  3482.           break;
  3483.  
  3484.         case 190:
  3485. /*   LDX,    ABSOLUTE_Y */
  3486.           {
  3487.         register p2 = load_abs_addr ();
  3488.         register unsigned src = LOAD (p2 + YR);
  3489.         PC += 3;
  3490.         if (pagetest (p2, YR))
  3491.           /* Over page */
  3492.           clkcount = 5;
  3493.         else
  3494.           /* Same page */
  3495.           clkcount = 4;
  3496.  
  3497.         SET_SIGN (src);
  3498.         SET_ZERO (src);
  3499.  
  3500.         XR = (src);
  3501.           }
  3502.  
  3503.           break;
  3504.  
  3505.         case 191:
  3506. /*   LAX,    ABSOLUTE_Y */
  3507.           {
  3508.         register p2 = load_abs_addr ();
  3509.         register unsigned src = LOAD (p2 + YR);
  3510.         PC += 3;
  3511.         if (pagetest (p2, YR))
  3512.           /* Over page */
  3513.           clkcount = 5;
  3514.         else
  3515.           /* Same page */
  3516.           clkcount = 4;
  3517.  
  3518.         SET_SIGN (src);
  3519.         SET_ZERO (src);
  3520.  
  3521.         AC = XR = (src);
  3522.           }
  3523.  
  3524.           break;
  3525.  
  3526.         case 192:
  3527.           {
  3528.         register p1 = LOAD (PC + 1);
  3529.         register unsigned src = p1;
  3530.         PC += 2;
  3531.  
  3532.         src = YR - src;
  3533.         SET_CARRY (src < 0x100);
  3534.         SET_SIGN (src);
  3535.         SET_ZERO (src &= 0xff);
  3536.         clkcount = 2;
  3537.           }
  3538.  
  3539.           break;
  3540.  
  3541.         case 193:
  3542.           {
  3543.         register p1 = LOAD (PC + 1);
  3544.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  3545.         PC += 2;
  3546.  
  3547.         src = AC - src;
  3548.         SET_CARRY (src < 0x100);
  3549.         SET_SIGN (src);
  3550.         SET_ZERO (src &= 0xff);
  3551.         clkcount = 6;
  3552.           }
  3553.  
  3554.           break;
  3555.  
  3556.         case 194:
  3557.           {
  3558.         PC += 2;
  3559.  
  3560.         clkcount = 2;
  3561.           }
  3562.  
  3563.           break;
  3564.  
  3565.         case 195:
  3566.           {
  3567.         register p1 = LOAD (PC + 1);
  3568.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  3569.         PC += 2;
  3570.  
  3571.         /* cmp(--src & 0xff));  */
  3572.  
  3573.         src = (src - 1) & 0xff;        /* DEC+CMP */
  3574.         SET_CARRY (AC >= src);
  3575.         SET_SIGN (AC - src);
  3576.         SET_ZERO (AC != src);
  3577.  
  3578.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  3579.         clkcount = 8;
  3580.           }
  3581.  
  3582.           break;
  3583.  
  3584.         case 196:
  3585.           {
  3586.         register p1 = LOAD (PC + 1);
  3587.         register unsigned src = LOAD_ZERO (p1);
  3588.         PC += 2;
  3589.  
  3590.         src = YR - src;
  3591.         SET_CARRY (src < 0x100);
  3592.         SET_SIGN (src);
  3593.         SET_ZERO (src &= 0xff);
  3594.         clkcount = 3;
  3595.           }
  3596.  
  3597.           break;
  3598.  
  3599.         case 197:
  3600.           {
  3601.         register p1 = LOAD (PC + 1);
  3602.         register unsigned src = LOAD_ZERO (p1);
  3603.         PC += 2;
  3604.  
  3605.         src = AC - src;
  3606.         SET_CARRY (src < 0x100);
  3607.         SET_SIGN (src);
  3608.         SET_ZERO (src &= 0xff);
  3609.         clkcount = 3;
  3610.           }
  3611.  
  3612.           break;
  3613.  
  3614.         case 198:
  3615.           {
  3616.         register p1 = LOAD (PC + 1);
  3617.         register unsigned src = LOAD_ZERO (p1);
  3618.         PC += 2;
  3619.  
  3620.         src = (src - 1) & 0xff;
  3621.         SET_SIGN (src);
  3622.         SET_ZERO (src);
  3623.  
  3624.         STORE_ZERO (p1, (src));;
  3625.         clkcount = 5;
  3626.           }
  3627.  
  3628.           break;
  3629.  
  3630.         case 199:
  3631.           {
  3632.         register p1 = LOAD (PC + 1);
  3633.         register unsigned src = LOAD_ZERO (p1);
  3634.         PC += 2;
  3635.  
  3636.         /* cmp(--src & 0xff));  */
  3637.  
  3638.         src = (src - 1) & 0xff;        /* DEC+CMP */
  3639.         SET_CARRY (AC >= src);
  3640.         SET_SIGN (AC - src);
  3641.         SET_ZERO (AC != src);
  3642.  
  3643.         STORE_ZERO (p1, (src));;
  3644.         clkcount = 5;
  3645.           }
  3646.  
  3647.           break;
  3648.  
  3649.         case 200:
  3650.           {
  3651.         register unsigned src = YR;
  3652.         PC++;
  3653.  
  3654.         src = (src + 1) & 0xff;
  3655.         SET_SIGN (src);
  3656.         SET_ZERO (src);
  3657.  
  3658.         YR = (src);;
  3659.         clkcount = 2;
  3660.           }
  3661.  
  3662.           break;
  3663.  
  3664.         case 201:
  3665.           {
  3666.         register p1 = LOAD (PC + 1);
  3667.         register unsigned src = p1;
  3668.         PC += 2;
  3669.  
  3670.         src = AC - src;
  3671.         SET_CARRY (src < 0x100);
  3672.         SET_SIGN (src);
  3673.         SET_ZERO (src &= 0xff);
  3674.         clkcount = 2;
  3675.           }
  3676.  
  3677.           break;
  3678.  
  3679.         case 202:
  3680.           {
  3681.         register unsigned src = XR;
  3682.         PC++;
  3683.  
  3684.         src = (src - 1) & 0xff;
  3685.         SET_SIGN (src);
  3686.         SET_ZERO (src);
  3687.  
  3688.         XR = (src);;
  3689.         clkcount = 2;
  3690.           }
  3691.  
  3692.           break;
  3693.  
  3694.         case 203:
  3695.           {
  3696.         register p1 = LOAD (PC + 1);
  3697.         register unsigned src = p1;
  3698.         PC += 2;
  3699.  
  3700.         src = (AC & XR) - src;    /* Carry is ignored (CMP) */
  3701.         /* Overflow flag may be affected */
  3702.         SET_CARRY (src < 0x100);
  3703.  
  3704.         src &= 0xff;    /* No decimal mode */
  3705.         SET_SIGN (src);
  3706.         SET_ZERO (src);
  3707.  
  3708.         XR = (src);;
  3709.         clkcount = 2;
  3710.           }
  3711.  
  3712.           break;
  3713.  
  3714.         case 204:
  3715.           {
  3716.         register p2 = load_abs_addr ();
  3717.         register unsigned src = LOAD (p2);
  3718.         PC += 3;
  3719.  
  3720.         src = YR - src;
  3721.         SET_CARRY (src < 0x100);
  3722.         SET_SIGN (src);
  3723.         SET_ZERO (src &= 0xff);
  3724.         clkcount = 4;
  3725.           }
  3726.  
  3727.           break;
  3728.  
  3729.         case 205:
  3730.           {
  3731.         register p2 = load_abs_addr ();
  3732.         register unsigned src = LOAD (p2);
  3733.         PC += 3;
  3734.  
  3735.         src = AC - src;
  3736.         SET_CARRY (src < 0x100);
  3737.         SET_SIGN (src);
  3738.         SET_ZERO (src &= 0xff);
  3739.         clkcount = 4;
  3740.           }
  3741.  
  3742.           break;
  3743.  
  3744.         case 206:
  3745.           {
  3746.         register p2 = load_abs_addr ();
  3747.         register unsigned src = LOAD (p2);
  3748.         PC += 3;
  3749.  
  3750.         src = (src - 1) & 0xff;
  3751.         SET_SIGN (src);
  3752.         SET_ZERO (src);
  3753.  
  3754.         STORE (p2, (src));;
  3755.         clkcount = 6;
  3756.           }
  3757.  
  3758.           break;
  3759.  
  3760.         case 207:
  3761.           {
  3762.         register p2 = load_abs_addr ();
  3763.         register unsigned src = LOAD (p2);
  3764.         PC += 3;
  3765.  
  3766.         /* cmp(--src & 0xff));  */
  3767.  
  3768.         src = (src - 1) & 0xff;        /* DEC+CMP */
  3769.         SET_CARRY (AC >= src);
  3770.         SET_SIGN (AC - src);
  3771.         SET_ZERO (AC != src);
  3772.  
  3773.         STORE (p2, (src));;
  3774.         clkcount = 6;
  3775.           }
  3776.  
  3777.           break;
  3778.  
  3779.         case 208:
  3780. /*  BNE,    RELATIVE */
  3781.           {
  3782.         register p1 = LOAD (PC + 1);
  3783.         register unsigned src = p1;
  3784.         register UBYTE hb;
  3785.         PC += 2;
  3786.         /* Branch if  zero flag is clear. */
  3787.         if (!IF_ZERO ())
  3788.           {
  3789.             hb = UPPER (PC);
  3790.             PC = REL_ADDR (PC, src);
  3791.             if (brtest (hb))
  3792.               /* Same page */
  3793.               clkcount = 3;
  3794.             else
  3795.               /* Different page */
  3796.               clkcount = 4;
  3797.           }
  3798.         else
  3799.           clkcount = 2;
  3800.           }
  3801.  
  3802.           break;
  3803.  
  3804.         case 209:
  3805. /*   CMP,    INDIRECT_Y */
  3806.           {
  3807.         register p1 = LOAD (PC + 1);
  3808.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  3809.         register unsigned src = LOAD (p2 + YR);
  3810.         PC += 2;
  3811.         if (pagetest (p2, YR))
  3812.           /* Over page */
  3813.           clkcount = 6;
  3814.         else
  3815.           /* Same page */
  3816.           clkcount = 5;
  3817.  
  3818.         src = AC - src;
  3819.         SET_CARRY (src < 0x100);
  3820.         SET_SIGN (src);
  3821.         SET_ZERO (src &= 0xff);
  3822.           }
  3823.  
  3824.           break;
  3825.  
  3826.         case 211:
  3827.           {
  3828.         register p1 = LOAD (PC + 1);
  3829.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  3830.         PC += 2;
  3831.  
  3832.         /* cmp(--src & 0xff));  */
  3833.  
  3834.         src = (src - 1) & 0xff;        /* DEC+CMP */
  3835.         SET_CARRY (AC >= src);
  3836.         SET_SIGN (AC - src);
  3837.         SET_ZERO (AC != src);
  3838.  
  3839.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  3840.         clkcount = 8;
  3841.           }
  3842.  
  3843.           break;
  3844.  
  3845.         case 212:
  3846.           {
  3847.         PC += 2;
  3848.  
  3849.         clkcount = 4;
  3850.           }
  3851.  
  3852.           break;
  3853.  
  3854.         case 213:
  3855.           {
  3856.         register p1 = LOAD (PC + 1);
  3857.         register unsigned src = LOAD_ZERO (p1 + XR);
  3858.         PC += 2;
  3859.  
  3860.         src = AC - src;
  3861.         SET_CARRY (src < 0x100);
  3862.         SET_SIGN (src);
  3863.         SET_ZERO (src &= 0xff);
  3864.         clkcount = 4;
  3865.           }
  3866.  
  3867.           break;
  3868.  
  3869.         case 214:
  3870.           {
  3871.         register p1 = LOAD (PC + 1);
  3872.         register unsigned src = LOAD_ZERO (p1 + XR);
  3873.         PC += 2;
  3874.  
  3875.         src = (src - 1) & 0xff;
  3876.         SET_SIGN (src);
  3877.         SET_ZERO (src);
  3878.  
  3879.         STORE_ZERO (p1 + XR, (src));;
  3880.         clkcount = 6;
  3881.           }
  3882.  
  3883.           break;
  3884.  
  3885.         case 215:
  3886.           {
  3887.         register p1 = LOAD (PC + 1);
  3888.         register unsigned src = LOAD_ZERO (p1 + XR);
  3889.         PC += 2;
  3890.  
  3891.         /* cmp(--src & 0xff));  */
  3892.  
  3893.         src = (src - 1) & 0xff;        /* DEC+CMP */
  3894.         SET_CARRY (AC >= src);
  3895.         SET_SIGN (AC - src);
  3896.         SET_ZERO (AC != src);
  3897.  
  3898.         STORE_ZERO (p1 + XR, (src));;
  3899.         clkcount = 6;
  3900.           }
  3901.  
  3902.           break;
  3903.  
  3904.         case 216:
  3905.           {
  3906.         PC++;
  3907.  
  3908.  
  3909.         SET_DECIMAL ((0));;
  3910.         clkcount = 2;
  3911.           }
  3912.  
  3913.           break;
  3914.  
  3915.         case 217:
  3916. /*   CMP,    ABSOLUTE_Y */
  3917.           {
  3918.         register p2 = load_abs_addr ();
  3919.         register unsigned src = LOAD (p2 + YR);
  3920.         PC += 3;
  3921.         if (pagetest (p2, YR))
  3922.           /* Over page */
  3923.           clkcount = 5;
  3924.         else
  3925.           /* Same page */
  3926.           clkcount = 4;
  3927.  
  3928.         src = AC - src;
  3929.         SET_CARRY (src < 0x100);
  3930.         SET_SIGN (src);
  3931.         SET_ZERO (src &= 0xff);
  3932.           }
  3933.  
  3934.           break;
  3935.  
  3936.         case 218:
  3937.           {
  3938.         PC++;
  3939.  
  3940.         clkcount = 2;
  3941.           }
  3942.  
  3943.           break;
  3944.  
  3945.         case 219:
  3946.           {
  3947.         register p2 = load_abs_addr ();
  3948.         register unsigned src = LOAD (p2 + YR);
  3949.         PC += 3;
  3950.  
  3951.         /* cmp(--src & 0xff));  */
  3952.  
  3953.         src = (src - 1) & 0xff;        /* DEC+CMP */
  3954.         SET_CARRY (AC >= src);
  3955.         SET_SIGN (AC - src);
  3956.         SET_ZERO (AC != src);
  3957.  
  3958.         STORE (p2 + YR, (src));;
  3959.         clkcount = 7;
  3960.           }
  3961.  
  3962.           break;
  3963.  
  3964.         case 220:
  3965.           {
  3966.         PC += 3;
  3967.  
  3968.         clkcount = 4;
  3969.           }
  3970.  
  3971.           break;
  3972.  
  3973.         case 221:
  3974. /*   CMP,    ABSOLUTE_X */
  3975.           {
  3976.         register p2 = load_abs_addr ();
  3977.         register unsigned src = LOAD (p2 + XR);
  3978.         PC += 3;
  3979.         if (pagetest (p2, XR))
  3980.           /* Over page */
  3981.           clkcount = 5;
  3982.         else
  3983.           /* Same page */
  3984.           clkcount = 4;
  3985.  
  3986.         src = AC - src;
  3987.         SET_CARRY (src < 0x100);
  3988.         SET_SIGN (src);
  3989.         SET_ZERO (src &= 0xff);
  3990.           }
  3991.  
  3992.           break;
  3993.  
  3994.         case 222:
  3995.           {
  3996.         register p2 = load_abs_addr ();
  3997.         register unsigned src = LOAD (p2 + XR);
  3998.         PC += 3;
  3999.  
  4000.         src = (src - 1) & 0xff;
  4001.         SET_SIGN (src);
  4002.         SET_ZERO (src);
  4003.  
  4004.         STORE (p2 + XR, (src));;
  4005.         clkcount = 7;
  4006.           }
  4007.  
  4008.           break;
  4009.  
  4010.         case 223:
  4011.           {
  4012.         register p2 = load_abs_addr ();
  4013.         register unsigned src = LOAD (p2 + XR);
  4014.         PC += 3;
  4015.  
  4016.         /* cmp(--src & 0xff));  */
  4017.  
  4018.         src = (src - 1) & 0xff;        /* DEC+CMP */
  4019.         SET_CARRY (AC >= src);
  4020.         SET_SIGN (AC - src);
  4021.         SET_ZERO (AC != src);
  4022.  
  4023.         STORE (p2 + XR, (src));;
  4024.         clkcount = 7;
  4025.           }
  4026.  
  4027.           break;
  4028.  
  4029.         case 224:
  4030.           {
  4031.         register p1 = LOAD (PC + 1);
  4032.         register unsigned src = p1;
  4033.         PC += 2;
  4034.  
  4035.         src = XR - src;
  4036.         SET_CARRY (src < 0x100);
  4037.         SET_SIGN (src);
  4038.         SET_ZERO (src &= 0xff);
  4039.         clkcount = 2;
  4040.           }
  4041.  
  4042.           break;
  4043.  
  4044.         case 225:
  4045.           {
  4046.         register p1 = LOAD (PC + 1);
  4047.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  4048.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4049.         PC += 2;
  4050.  
  4051.         /*
  4052.          * SBC is not exact either. It has 6% different results too.
  4053.          */
  4054.  
  4055.  
  4056.         SET_SIGN (temp);
  4057.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4058.  
  4059.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4060.  
  4061.         if (IF_DECIMAL ())
  4062.           {
  4063.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4064.               temp -= 6;
  4065.             if (temp > 0x99)
  4066.               temp -= 0x60;
  4067.           }
  4068.         SET_CARRY (temp < 0x100);
  4069.  
  4070.         AC = (temp & 0xff);;
  4071.         clkcount = 6;
  4072.           }
  4073.  
  4074.           break;
  4075.  
  4076.         case 226:
  4077.           {
  4078.         PC += 2;
  4079.  
  4080.         clkcount = 2;
  4081.           }
  4082.  
  4083.           break;
  4084.  
  4085.         case 227:
  4086.           {
  4087.         register p1 = LOAD (PC + 1);
  4088.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1 + XR));
  4089.         register unsigned int temp;
  4090.         PC += 2;
  4091.  
  4092.  
  4093.         /* src = ++src & 0xff; AC = sbc(src); */
  4094.  
  4095.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4096.  
  4097.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4098.  
  4099.         SET_SIGN (temp);
  4100.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4101.  
  4102.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4103.  
  4104.         if (IF_DECIMAL ())
  4105.           {
  4106.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4107.               temp -= 6;
  4108.             if (temp > 0x99)
  4109.               temp -= 0x60;
  4110.           }
  4111.         SET_CARRY (temp < 0x100);
  4112.  
  4113.         AC = temp;
  4114.         /* src saved */
  4115.         STORE (LOAD_ZERO_ADDR (p1 + XR), (src));;
  4116.         clkcount = 8;
  4117.           }
  4118.  
  4119.           break;
  4120.  
  4121.         case 228:
  4122.           {
  4123.         register p1 = LOAD (PC + 1);
  4124.         register unsigned src = LOAD_ZERO (p1);
  4125.         PC += 2;
  4126.  
  4127.         src = XR - src;
  4128.         SET_CARRY (src < 0x100);
  4129.         SET_SIGN (src);
  4130.         SET_ZERO (src &= 0xff);
  4131.         clkcount = 3;
  4132.           }
  4133.  
  4134.           break;
  4135.  
  4136.         case 229:
  4137.           {
  4138.         register p1 = LOAD (PC + 1);
  4139.         register unsigned src = LOAD_ZERO (p1);
  4140.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4141.         PC += 2;
  4142.  
  4143.         /*
  4144.          * SBC is not exact either. It has 6% different results too.
  4145.          */
  4146.  
  4147.  
  4148.         SET_SIGN (temp);
  4149.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4150.  
  4151.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4152.  
  4153.         if (IF_DECIMAL ())
  4154.           {
  4155.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4156.               temp -= 6;
  4157.             if (temp > 0x99)
  4158.               temp -= 0x60;
  4159.           }
  4160.         SET_CARRY (temp < 0x100);
  4161.  
  4162.         AC = (temp & 0xff);;
  4163.         clkcount = 3;
  4164.           }
  4165.  
  4166.           break;
  4167.  
  4168.         case 230:
  4169.           {
  4170.         register p1 = LOAD (PC + 1);
  4171.         register unsigned src = LOAD_ZERO (p1);
  4172.         PC += 2;
  4173.  
  4174.         src = (src + 1) & 0xff;
  4175.         SET_SIGN (src);
  4176.         SET_ZERO (src);
  4177.  
  4178.         STORE_ZERO (p1, (src));;
  4179.         clkcount = 5;
  4180.           }
  4181.  
  4182.           break;
  4183.  
  4184.         case 231:
  4185.           {
  4186.         register p1 = LOAD (PC + 1);
  4187.         register unsigned src = LOAD_ZERO (p1);
  4188.         register unsigned int temp;
  4189.         PC += 2;
  4190.  
  4191.  
  4192.         /* src = ++src & 0xff; AC = sbc(src); */
  4193.  
  4194.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4195.  
  4196.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4197.  
  4198.         SET_SIGN (temp);
  4199.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4200.  
  4201.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4202.  
  4203.         if (IF_DECIMAL ())
  4204.           {
  4205.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4206.               temp -= 6;
  4207.             if (temp > 0x99)
  4208.               temp -= 0x60;
  4209.           }
  4210.         SET_CARRY (temp < 0x100);
  4211.  
  4212.         AC = temp;
  4213.         /* src saved */
  4214.         STORE_ZERO (p1, (src));;
  4215.         clkcount = 5;
  4216.           }
  4217.  
  4218.           break;
  4219.  
  4220.         case 232:
  4221.           {
  4222.         register unsigned src = XR;
  4223.         PC++;
  4224.  
  4225.         src = (src + 1) & 0xff;
  4226.         SET_SIGN (src);
  4227.         SET_ZERO (src);
  4228.  
  4229.         XR = (src);;
  4230.         clkcount = 2;
  4231.           }
  4232.  
  4233.           break;
  4234.  
  4235.         case 233:
  4236. /*  SBC,    IMMEDIATE */
  4237.           {
  4238.         register p1 = LOAD (PC + 1);
  4239.         register unsigned src = p1;
  4240.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4241.         PC += 2;
  4242.  
  4243.         /*
  4244.          * SBC is not exact either. It has 6% different results too.
  4245.          */
  4246.  
  4247.         if (!IF_DECIMAL ())
  4248.           {
  4249.             SET_SIGN (temp);
  4250.             SET_ZERO (temp & 0xff);    /* Sign and Zero are invalid in decimal mode */
  4251.  
  4252.             SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4253.             SET_CARRY (temp < 0x100);
  4254.             AC = (temp & 0xff);
  4255.  
  4256.           }
  4257.         else
  4258.           {
  4259.             int bcd1, bcd2;
  4260.             UBYTE old_A;
  4261.             int C = IF_CARRY ()? 1 : 0;
  4262.  
  4263.             old_A = AC;
  4264.  
  4265.             bcd1 = fromBCD (AC);
  4266.             bcd2 = fromBCD (src);
  4267.  
  4268.             bcd1 = bcd1 - bcd2 - !C;
  4269.  
  4270.             if (bcd1 < 0)
  4271.               bcd1 = 100 - (-bcd1);
  4272.             AC = toBCD (bcd1);
  4273.  
  4274.             SET_CARRY ((old_A < (src + !C)) ? 0 : 1);
  4275.             SET_OVERFLOW ((old_A ^ AC) & 0x80);
  4276.           }
  4277.         clkcount = 2;
  4278.           }
  4279.  
  4280.           break;
  4281.  
  4282.         case 234:
  4283.           {
  4284.         PC++;
  4285.  
  4286.         clkcount = 2;
  4287.           }
  4288.  
  4289.           break;
  4290.  
  4291.         case 235:
  4292.           {
  4293.         register p1 = LOAD (PC + 1);
  4294.         register unsigned src = p1;
  4295.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4296.         PC += 2;
  4297.  
  4298.         /*
  4299.          * SBC is not exact either. It has 6% different results too.
  4300.          */
  4301.  
  4302.  
  4303.         SET_SIGN (temp);
  4304.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4305.  
  4306.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4307.  
  4308.         if (IF_DECIMAL ())
  4309.           {
  4310.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4311.               temp -= 6;
  4312.             if (temp > 0x99)
  4313.               temp -= 0x60;
  4314.           }
  4315.         SET_CARRY (temp < 0x100);
  4316.  
  4317.         AC = (temp & 0xff);;
  4318.         clkcount = 2;
  4319.           }
  4320.  
  4321.           break;
  4322.  
  4323.         case 236:
  4324.           {
  4325.         register p2 = load_abs_addr ();
  4326.         register unsigned src = LOAD (p2);
  4327.         PC += 3;
  4328.  
  4329.         src = XR - src;
  4330.         SET_CARRY (src < 0x100);
  4331.         SET_SIGN (src);
  4332.         SET_ZERO (src &= 0xff);
  4333.         clkcount = 4;
  4334.           }
  4335.  
  4336.           break;
  4337.  
  4338.         case 237:
  4339.           {
  4340.         register p2 = load_abs_addr ();
  4341.         register unsigned src = LOAD (p2);
  4342.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4343.         PC += 3;
  4344.  
  4345.         /*
  4346.          * SBC is not exact either. It has 6% different results too.
  4347.          */
  4348.  
  4349.  
  4350.         SET_SIGN (temp);
  4351.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4352.  
  4353.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4354.  
  4355.         if (IF_DECIMAL ())
  4356.           {
  4357.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4358.               temp -= 6;
  4359.             if (temp > 0x99)
  4360.               temp -= 0x60;
  4361.           }
  4362.         SET_CARRY (temp < 0x100);
  4363.  
  4364.         AC = (temp & 0xff);;
  4365.         clkcount = 4;
  4366.           }
  4367.  
  4368.           break;
  4369.  
  4370.         case 238:
  4371.           {
  4372.         register p2 = load_abs_addr ();
  4373.         register unsigned src = LOAD (p2);
  4374.         PC += 3;
  4375.  
  4376.         src = (src + 1) & 0xff;
  4377.         SET_SIGN (src);
  4378.         SET_ZERO (src);
  4379.  
  4380.         STORE (p2, (src));;
  4381.         clkcount = 6;
  4382.           }
  4383.  
  4384.           break;
  4385.  
  4386.         case 239:
  4387.           {
  4388.         register p2 = load_abs_addr ();
  4389.         register unsigned src = LOAD (p2);
  4390.         register unsigned int temp;
  4391.         PC += 3;
  4392.  
  4393.  
  4394.         /* src = ++src & 0xff; AC = sbc(src); */
  4395.  
  4396.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4397.  
  4398.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4399.  
  4400.         SET_SIGN (temp);
  4401.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4402.  
  4403.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4404.  
  4405.         if (IF_DECIMAL ())
  4406.           {
  4407.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4408.               temp -= 6;
  4409.             if (temp > 0x99)
  4410.               temp -= 0x60;
  4411.           }
  4412.         SET_CARRY (temp < 0x100);
  4413.  
  4414.         AC = temp;
  4415.         /* src saved */
  4416.         STORE (p2, (src));;
  4417.         clkcount = 6;
  4418.           }
  4419.  
  4420.           break;
  4421.  
  4422.         case 240:
  4423. /*   BEQ,    RELATIVE */
  4424.           {
  4425.         register p1 = LOAD (PC + 1);
  4426.         register unsigned src = p1;
  4427.         register UBYTE hb;
  4428.         PC += 2;
  4429.         /* Branch if  zero flag is set. */
  4430.         if (IF_ZERO ())
  4431.           {
  4432.             hb = UPPER (PC);
  4433.             PC = REL_ADDR (PC, src);
  4434.             if (brtest (hb))
  4435.               /* Same page */
  4436.               clkcount = 3;
  4437.             else
  4438.               /* Different page */
  4439.               clkcount = 4;
  4440.           }
  4441.         else
  4442.           clkcount = 2;
  4443.           }
  4444.  
  4445.           break;
  4446.  
  4447.         case 241:
  4448.           {
  4449.         register p1 = LOAD (PC + 1);
  4450.         register ADDRESS p2 = LOAD_ZERO_ADDR (p1);
  4451.         register unsigned src = LOAD (p2 + YR);
  4452.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4453.         PC += 2;
  4454.  
  4455.         if (pagetest (p2, YR))
  4456.           /* Over page */
  4457.           clkcount = 6;
  4458.         else
  4459.           /* Same page */
  4460.           clkcount = 5;
  4461.  
  4462.         /*
  4463.          * SBC is not exact either. It has 6% different results too.
  4464.          */
  4465.  
  4466.  
  4467.         SET_SIGN (temp);
  4468.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4469.  
  4470.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4471.  
  4472.         if (IF_DECIMAL ())
  4473.           {
  4474.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4475.               temp -= 6;
  4476.             if (temp > 0x99)
  4477.               temp -= 0x60;
  4478.           }
  4479.         SET_CARRY (temp < 0x100);
  4480.  
  4481.         AC = (temp & 0xff);
  4482.           }
  4483.  
  4484.           break;
  4485.  
  4486.         case 243:
  4487.           {
  4488.         register p1 = LOAD (PC + 1);
  4489.         register unsigned src = LOAD (LOAD_ZERO_ADDR (p1) + YR);
  4490.         register unsigned int temp;
  4491.         PC += 2;
  4492.  
  4493.  
  4494.         /* src = ++src & 0xff; AC = sbc(src); */
  4495.  
  4496.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4497.  
  4498.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4499.  
  4500.         SET_SIGN (temp);
  4501.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4502.  
  4503.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4504.  
  4505.         if (IF_DECIMAL ())
  4506.           {
  4507.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4508.               temp -= 6;
  4509.             if (temp > 0x99)
  4510.               temp -= 0x60;
  4511.           }
  4512.         SET_CARRY (temp < 0x100);
  4513.  
  4514.         AC = temp;
  4515.         /* src saved */
  4516.         STORE (LOAD_ZERO_ADDR (p1) + YR, (src));;
  4517.         clkcount = 8;
  4518.           }
  4519.  
  4520.           break;
  4521.  
  4522.         case 244:
  4523.           {
  4524.         PC += 2;
  4525.  
  4526.         clkcount = 4;
  4527.           }
  4528.  
  4529.           break;
  4530.  
  4531.         case 245:
  4532.           {
  4533.         register p1 = LOAD (PC + 1);
  4534.         register unsigned src = LOAD_ZERO (p1 + XR);
  4535.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4536.         PC += 2;
  4537.  
  4538.         /*
  4539.          * SBC is not exact either. It has 6% different results too.
  4540.          */
  4541.  
  4542.  
  4543.         SET_SIGN (temp);
  4544.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4545.  
  4546.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4547.  
  4548.         if (IF_DECIMAL ())
  4549.           {
  4550.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4551.               temp -= 6;
  4552.             if (temp > 0x99)
  4553.               temp -= 0x60;
  4554.           }
  4555.         SET_CARRY (temp < 0x100);
  4556.  
  4557.         AC = (temp & 0xff);;
  4558.         clkcount = 4;
  4559.           }
  4560.  
  4561.           break;
  4562.  
  4563.         case 246:
  4564.           {
  4565.         register p1 = LOAD (PC + 1);
  4566.         register unsigned src = LOAD_ZERO (p1 + XR);
  4567.         PC += 2;
  4568.  
  4569.         src = (src + 1) & 0xff;
  4570.         SET_SIGN (src);
  4571.         SET_ZERO (src);
  4572.  
  4573.         STORE_ZERO (p1 + XR, (src));;
  4574.         clkcount = 6;
  4575.           }
  4576.  
  4577.           break;
  4578.  
  4579.         case 247:
  4580.           {
  4581.         register p1 = LOAD (PC + 1);
  4582.         register unsigned src = LOAD_ZERO (p1 + XR);
  4583.         register unsigned int temp;
  4584.         PC += 2;
  4585.  
  4586.  
  4587.         /* src = ++src & 0xff; AC = sbc(src); */
  4588.  
  4589.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4590.  
  4591.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4592.  
  4593.         SET_SIGN (temp);
  4594.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4595.  
  4596.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4597.  
  4598.         if (IF_DECIMAL ())
  4599.           {
  4600.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4601.               temp -= 6;
  4602.             if (temp > 0x99)
  4603.               temp -= 0x60;
  4604.           }
  4605.         SET_CARRY (temp < 0x100);
  4606.  
  4607.         AC = temp;
  4608.         /* src saved */
  4609.         STORE_ZERO (p1 + XR, (src));;
  4610.         clkcount = 6;
  4611.           }
  4612.  
  4613.           break;
  4614.  
  4615.         case 248:
  4616. /*  SED,    IMPLIED */
  4617.           {
  4618.         PC++;
  4619.  
  4620.         SET_DECIMAL ((1));;
  4621.         clkcount = 2;
  4622.           }
  4623.  
  4624.           break;
  4625.  
  4626.         case 249:
  4627. /*  SBC,    ABSOLUTE_Y */
  4628.           {
  4629.         register p2 = load_abs_addr ();
  4630.         register unsigned src = LOAD (p2 + YR);
  4631.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4632.         PC += 3;
  4633.  
  4634.         if (pagetest (p2, YR))
  4635.           /* Over page */
  4636.           clkcount = 5;
  4637.         else
  4638.           /* Same page */
  4639.           clkcount = 4;
  4640.  
  4641.         /*
  4642.          * SBC is not exact either. It has 6% different results too.
  4643.          */
  4644.  
  4645.  
  4646.         SET_SIGN (temp);
  4647.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4648.  
  4649.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4650.  
  4651.         if (IF_DECIMAL ())
  4652.           {
  4653.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4654.               temp -= 6;
  4655.             if (temp > 0x99)
  4656.               temp -= 0x60;
  4657.           }
  4658.         SET_CARRY (temp < 0x100);
  4659.  
  4660.         AC = (temp & 0xff);
  4661.           }
  4662.  
  4663.           break;
  4664.  
  4665.         case 250:
  4666.           {
  4667.         PC++;
  4668.  
  4669.         clkcount = 2;
  4670.           }
  4671.  
  4672.           break;
  4673.  
  4674.         case 251:
  4675.           {
  4676.         register p2 = load_abs_addr ();
  4677.         register unsigned src = LOAD (p2 + YR);
  4678.         register unsigned int temp;
  4679.         PC += 3;
  4680.  
  4681.  
  4682.         /* src = ++src & 0xff; AC = sbc(src); */
  4683.  
  4684.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4685.  
  4686.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4687.  
  4688.         SET_SIGN (temp);
  4689.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4690.  
  4691.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4692.  
  4693.         if (IF_DECIMAL ())
  4694.           {
  4695.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4696.               temp -= 6;
  4697.             if (temp > 0x99)
  4698.               temp -= 0x60;
  4699.           }
  4700.         SET_CARRY (temp < 0x100);
  4701.  
  4702.         AC = temp;
  4703.         /* src saved */
  4704.         STORE (p2 + YR, (src));;
  4705.         clkcount = 7;
  4706.           }
  4707.  
  4708.           break;
  4709.  
  4710.         case 252:
  4711.           {
  4712.         PC += 3;
  4713.  
  4714.         clkcount = 4;
  4715.           }
  4716.  
  4717.           break;
  4718.  
  4719.         case 253:
  4720. /*   SBC,    ABSOLUTE_X */
  4721.           {
  4722.         register p2 = load_abs_addr ();
  4723.         register unsigned src = LOAD (p2 + XR);
  4724.         register unsigned int temp = AC - src - (IF_CARRY ()? 0 : 1);
  4725.         PC += 3;
  4726.  
  4727.         if (pagetest (p2, XR))
  4728.           /* Over page */
  4729.           clkcount = 5;
  4730.         else
  4731.           /* Same page */
  4732.           clkcount = 4;
  4733.  
  4734.         /*
  4735.          * SBC is not exact either. It has 6% different results too.
  4736.          */
  4737.  
  4738.  
  4739.         SET_SIGN (temp);
  4740.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4741.  
  4742.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4743.  
  4744.         if (IF_DECIMAL ())
  4745.           {
  4746.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4747.               temp -= 6;
  4748.             if (temp > 0x99)
  4749.               temp -= 0x60;
  4750.           }
  4751.         SET_CARRY (temp < 0x100);
  4752.  
  4753.         AC = (temp & 0xff);
  4754.           }
  4755.  
  4756.           break;
  4757.  
  4758.         case 254:
  4759.           {
  4760.         register p2 = load_abs_addr ();
  4761.         register unsigned src = LOAD (p2 + XR);
  4762.         PC += 3;
  4763.  
  4764.         src = (src + 1) & 0xff;
  4765.         SET_SIGN (src);
  4766.         SET_ZERO (src);
  4767.  
  4768.         STORE (p2 + XR, (src));;
  4769.         clkcount = 7;
  4770.           }
  4771.  
  4772.           break;
  4773.  
  4774.         case 255:
  4775.           {
  4776.         register p2 = load_abs_addr ();
  4777.         register unsigned src = LOAD (p2 + XR);
  4778.         register unsigned int temp;
  4779.         PC += 3;
  4780.  
  4781.  
  4782.         /* src = ++src & 0xff; AC = sbc(src); */
  4783.  
  4784.         src = ((src + 1) & 0xff);    /* INC+SBC */
  4785.  
  4786.         temp = AC - src - (IF_CARRY ()? 0 : 1);
  4787.  
  4788.         SET_SIGN (temp);
  4789.         SET_ZERO (temp & 0xff);        /* Sign and Zero are invalid in decimal mode */
  4790.  
  4791.         SET_OVERFLOW (((AC ^ temp) & 0x80) && ((AC ^ src) & 0x80));
  4792.  
  4793.         if (IF_DECIMAL ())
  4794.           {
  4795.             if (((AC & 0xf) + (IF_CARRY ()? 1 : 0)) < (src & 0xf))
  4796.               temp -= 6;
  4797.             if (temp > 0x99)
  4798.               temp -= 0x60;
  4799.           }
  4800.         SET_CARRY (temp < 0x100);
  4801.  
  4802.         AC = temp;
  4803.         /* src saved */
  4804.         STORE (p2 + XR, (src));;
  4805.         clkcount = 7;
  4806.           }
  4807.  
  4808.           break;
  4809.  
  4810.         default:
  4811.           {
  4812.         PC++;
  4813.         /* No such opcode. */
  4814.         (void) printf ("Illegal instruction.\n");
  4815.         show ();
  4816.           }
  4817.         }            /* switch */
  4818.  
  4819.       clk += clkcount;
  4820.  
  4821.     }            /* while(1) */
  4822.     }                /* while(!reset_flag) */
  4823. }                /* mainloop */
  4824.  
  4825. /* Loads an absolute address uising the quicker load mechanism */
  4826. __inline ADDRESS
  4827. load_abs_addr (void)
  4828. {
  4829.   return (ADDRESS)(LOADEXEC (PC + 1) | (LOADEXEC (PC + 2) << 8));
  4830. }
  4831.  
  4832. /* Used in variable cycle time indexed addressing */
  4833. /* a: address to be incremented */
  4834. /* b: increment value */
  4835. /* returns: TRUE if an address increment will cross a page boundary */
  4836. __inline int
  4837. pagetest (ADDRESS a, UBYTE b)
  4838. {
  4839.   return (LOWER (a) + b > 0xff);
  4840. }
  4841.  
  4842. /* Used in variable cycle time branches */
  4843. /* a: high byte of new address */
  4844. /* returns: TRUE if a branch is to the same page */
  4845. __inline int
  4846. brtest (UBYTE a)
  4847. {
  4848.   return (UPPER (PC) == (a));
  4849. }
  4850.  
  4851. /* Convert from binary to BCD (Binary Coded Decimal) */
  4852. /* a: binary value */
  4853. /* returns: BCD value */
  4854. __inline int
  4855. toBCD (int a)
  4856. {
  4857.   return (((a % 100) / 10) << 4) | (a % 10);
  4858. }
  4859.  
  4860. /* Convert from BCD to binary */
  4861. /* a: BCD value */
  4862. /* returns: binary value */
  4863. __inline int
  4864. fromBCD (int a)
  4865. {
  4866.   return ((a >> 4) & 0xf) * 10 + (a & 0xf);
  4867. }
  4868.